{-# OPTIONS_GHC -XDeriveDataTypeable #-}
module WS.XI.Com.Sap.Aii.Ibdir.Server.Api.Types where
import Data.Typeable
import Data.Time.LocalTime

import WS.Runtime.Xmlable

import qualified WS.XI.Com.Sap.Aii.Ib.Server.Api.Types as S0

nss :: [(String, String)]
nss = [("tns","urn:com.sap.aii.ibdir.server.api.types"),("s0","urn:com.sap.aii.ib.server.api.types")]
-- types definition

data LogMessageItem__ = LogMessageItem__ {
    severityCodeLogMessageItem :: Maybe String,
    classificationCodeLogMessageItem :: Maybe String,
    messageLogMessageItem :: Maybe Text__
} deriving (Typeable, Eq) 

data Text__ = Text__ {
    languageCodeText :: Maybe String,
    valueText :: Maybe String
} deriving (Typeable, Eq) 

data LogMessageCommunicationChannel__ = LogMessageCommunicationChannel__ {
    communicationChannelIDLogMessageCommunicationChannel :: Maybe CommunicationChannelID__,
    logMessageItemLogMessageCommunicationChannel :: Maybe LogMessageItem__
} deriving (Typeable, Eq) 

data CommunicationChannelID__ = CommunicationChannelID__ {
    partyIDCommunicationChannelID :: Maybe String,
    componentIDCommunicationChannelID :: Maybe String,
    channelIDCommunicationChannelID :: Maybe String
} deriving (Typeable, Eq) 

data BusinessComponentIdentifierCollection__ = BusinessComponentIdentifierCollection__ {
    businessComponentIDBusinessComponentIdentifierCollection :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data CommunicationComponentID__ = CommunicationComponentID__ {
    partyIDCommunicationComponentID :: Maybe String,
    componentIDCommunicationComponentID :: Maybe String
} deriving (Typeable, Eq) 

data LogMessageMessageHeader__ = LogMessageMessageHeader__ {
    messageHeaderLogMessageMessageHeader :: Maybe MessageHeaderID__,
    logMessageItemLogMessageMessageHeader :: Maybe LogMessageItem__
} deriving (Typeable, Eq) 

data MessageHeaderID__ = MessageHeaderID__ {
    senderPartyIDMessageHeaderID :: Maybe String,
    senderComponentIDMessageHeaderID :: Maybe String,
    interfaceNameMessageHeaderID :: Maybe String,
    interfaceNamespaceMessageHeaderID :: Maybe String,
    receiverPartyIDMessageHeaderID :: Maybe String,
    receiverComponentIDMessageHeaderID :: Maybe String
} deriving (Typeable, Eq) 

data LogMessageConfigurationScenario__ = LogMessageConfigurationScenario__ {
    configurationScenarioIDLogMessageConfigurationScenario :: Maybe String,
    logMessageItemLogMessageConfigurationScenario :: Maybe LogMessageItem__
} deriving (Typeable, Eq) 

data LogMessageParty__ = LogMessageParty__ {
    partyIDLogMessageParty :: Maybe String,
    logMessageItemLogMessageParty :: Maybe LogMessageItem__
} deriving (Typeable, Eq) 

data BusinessComponentOpenForEditOut__ = BusinessComponentOpenForEditOut__ {
    changeListIDBusinessComponentOpenForEditOut :: Maybe S0.ChangeListID__,
    businessComponentBusinessComponentOpenForEditOut :: Maybe [BusinessComponent__],
    logMessageCollectionBusinessComponentOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data BusinessComponent__ = BusinessComponent__ {
    masterLanguageBusinessComponent :: Maybe String,
    administrativeDataBusinessComponent :: Maybe S0.ObjectAdministrativeData__,
    descriptionBusinessComponent :: Maybe [S0.LONG_Description__],
    businessComponentIDBusinessComponent :: Maybe CommunicationComponentID__,
    inboundInterfaceBusinessComponent :: Maybe [DesignObjectID__],
    outboundInterfaceBusinessComponent :: Maybe [DesignObjectID__],
    additionalIdentifierBusinessComponent :: Maybe [CommunicationComponentAdditionalIdentifier__],
    isThirdPartyBusinessComponent :: Maybe Bool,
    assignedUserBusinessComponent :: Maybe [String]
} deriving (Typeable, Eq) 

data DesignObjectID__ = DesignObjectID__ {
    nameDesignObjectID :: Maybe String,
    namespaceDesignObjectID :: Maybe String,
    softwareComponentVersionIDDesignObjectID :: Maybe String
} deriving (Typeable, Eq) 

data CommunicationComponentAdditionalIdentifier__ = CommunicationComponentAdditionalIdentifier__ {
    schemeIDCommunicationComponentAdditionalIdentifier :: Maybe String,
    valueCommunicationComponentAdditionalIdentifier :: Maybe String
} deriving (Typeable, Eq) 

data LogMessageCollection__ = LogMessageCollection__ {
    logMessageLogMessageCollection :: Maybe [LogMessage__],
    logMessageChangeListLogMessageCollection :: Maybe [LogMessageChangeList__],
    logMessagePartyLogMessageCollection :: Maybe [LogMessageParty__],
    logMessageBusinessSystemLogMessageCollection :: Maybe [LogMessageCommunicationComponent__],
    logMessageBusinessComponentLogMessageCollection :: Maybe [LogMessageCommunicationComponent__],
    logMessageIntegrationProcessLogMessageCollection :: Maybe [LogMessageCommunicationComponent__],
    logMessageCommunicationChannelLogMessageCollection :: Maybe [LogMessageCommunicationChannel__],
    logMessageSenderAgreementLogMessageCollection :: Maybe [LogMessageMessageHeader__],
    logMessageReceiverAgreementLogMessageCollection :: Maybe [LogMessageMessageHeader__],
    logMessageInterfaceDeterminationLogMessageCollection :: Maybe [LogMessageMessageHeader__],
    logMessageReceiverDeterminationLogMessageCollection :: Maybe [LogMessageMessageHeader__],
    logMessageValueMappingLogMessageCollection :: Maybe [LogMessageValueMapping__],
    logMessageConfigurationScenarioLogMessageCollection :: Maybe [LogMessageConfigurationScenario__]
} deriving (Typeable, Eq) 

data LogMessage__ = LogMessage__ {
    logMessageItemLogMessage :: Maybe LogMessageItem__
} deriving (Typeable, Eq) 

data LogMessageChangeList__ = LogMessageChangeList__ {
    changeListIDLogMessageChangeList :: Maybe S0.ChangeListID__,
    logMessageItemLogMessageChangeList :: Maybe LogMessageItem__
} deriving (Typeable, Eq) 

data LogMessageCommunicationComponent__ = LogMessageCommunicationComponent__ {
    communicationComponentIDLogMessageCommunicationComponent :: Maybe CommunicationComponentID__,
    logMessageItemLogMessageCommunicationComponent :: Maybe LogMessageItem__
} deriving (Typeable, Eq) 

data LogMessageValueMapping__ = LogMessageValueMapping__ {
    valueMappingIDLogMessageValueMapping :: Maybe String,
    logMessageItemLogMessageValueMapping :: Maybe LogMessageItem__
} deriving (Typeable, Eq) 

data BusinessComponentRestricted__ = BusinessComponentRestricted__ {
    masterLanguageBusinessComponentRestricted :: Maybe String,
    administrativeDataBusinessComponentRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionBusinessComponentRestricted :: Maybe [S0.LONG_Description__],
    businessComponentIDBusinessComponentRestricted :: Maybe CommunicationComponentID__,
    inboundInterfaceBusinessComponentRestricted :: Maybe [DesignObjectID__],
    outboundInterfaceBusinessComponentRestricted :: Maybe [DesignObjectID__],
    additionalIdentifierBusinessComponentRestricted :: Maybe [CommunicationComponentAdditionalIdentifier__],
    isThirdPartyBusinessComponentRestricted :: Maybe Bool,
    assignedUserBusinessComponentRestricted :: Maybe [String]
} deriving (Typeable, Eq) 

data BusinessComponentDeleteOpenForEditIn__ = BusinessComponentDeleteOpenForEditIn__ {
    changeListIDBusinessComponentDeleteOpenForEditIn :: Maybe String,
    businessComponentIDBusinessComponentDeleteOpenForEditIn :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data ConfigurationObjectModifyOut__ = ConfigurationObjectModifyOut__ {
    changeListIDConfigurationObjectModifyOut :: Maybe S0.ChangeListID__,
    logMessageCollectionConfigurationObjectModifyOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data BusinessComponentQueryIn__ = BusinessComponentQueryIn__ {
    businessComponentIDBusinessComponentQueryIn :: Maybe CommunicationComponentID__,
    descriptionBusinessComponentQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataBusinessComponentQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data BusinessComponentQueryOut__ = BusinessComponentQueryOut__ {
    businessComponentIDBusinessComponentQueryOut :: Maybe [CommunicationComponentID__],
    logMessageCollectionBusinessComponentQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data BusinessComponentCreateChangeIn__ = BusinessComponentCreateChangeIn__ {
    changeListIDBusinessComponentCreateChangeIn :: Maybe String,
    businessComponentBusinessComponentCreateChangeIn :: Maybe [BusinessComponentRestricted__]
} deriving (Typeable, Eq) 

data BusinessComponentReadIn__ = BusinessComponentReadIn__ {
    readContextBusinessComponentReadIn :: Maybe String,
    businessComponentIDBusinessComponentReadIn :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data BusinessComponentReadOut__ = BusinessComponentReadOut__ {
    businessComponentBusinessComponentReadOut :: Maybe [BusinessComponent__],
    logMessageCollectionBusinessComponentReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ArrayOfLogMessageParty__ = ArrayOfLogMessageParty__ {
    logMessagePartyArrayOfLogMessageParty :: Maybe [LogMessageParty__]
} deriving (Typeable, Eq) 

data ArrayOfLogMessageConfigurationScenario__ = ArrayOfLogMessageConfigurationScenario__ {
    logMessageConfigurationScenarioArrayOfLogMessageConfigurationScenario :: Maybe [LogMessageConfigurationScenario__]
} deriving (Typeable, Eq) 

data ArrayOfLogMessage__ = ArrayOfLogMessage__ {
    logMessageArrayOfLogMessage :: Maybe [LogMessage__]
} deriving (Typeable, Eq) 

data ArrayOfCommunicationComponentID__ = ArrayOfCommunicationComponentID__ {
    communicationComponentIDArrayOfCommunicationComponentID :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data ArrayOfLogMessageMessageHeader__ = ArrayOfLogMessageMessageHeader__ {
    logMessageMessageHeaderArrayOfLogMessageMessageHeader :: Maybe [LogMessageMessageHeader__]
} deriving (Typeable, Eq) 

data ArrayOfLogMessageValueMapping__ = ArrayOfLogMessageValueMapping__ {
    logMessageValueMappingArrayOfLogMessageValueMapping :: Maybe [LogMessageValueMapping__]
} deriving (Typeable, Eq) 

data ArrayOfCommunicationComponentAdditionalIdentifier__ = ArrayOfCommunicationComponentAdditionalIdentifier__ {
    communicationComponentAdditionalIdentifierArrayOfCommunicationComponentAdditionalIdentifier :: Maybe [CommunicationComponentAdditionalIdentifier__]
} deriving (Typeable, Eq) 

data ArrayOfLogMessageCommunicationChannel__ = ArrayOfLogMessageCommunicationChannel__ {
    logMessageCommunicationChannelArrayOfLogMessageCommunicationChannel :: Maybe [LogMessageCommunicationChannel__]
} deriving (Typeable, Eq) 

data ArrayOfLogMessageCommunicationComponent__ = ArrayOfLogMessageCommunicationComponent__ {
    logMessageCommunicationComponentArrayOfLogMessageCommunicationComponent :: Maybe [LogMessageCommunicationComponent__]
} deriving (Typeable, Eq) 

data ArrayOfLogMessageChangeList__ = ArrayOfLogMessageChangeList__ {
    logMessageChangeListArrayOfLogMessageChangeList :: Maybe [LogMessageChangeList__]
} deriving (Typeable, Eq) 

data ArrayOfDesignObjectID__ = ArrayOfDesignObjectID__ {
    designObjectIDArrayOfDesignObjectID :: Maybe [DesignObjectID__]
} deriving (Typeable, Eq) 

data ArrayOfBusinessComponentRestricted__ = ArrayOfBusinessComponentRestricted__ {
    businessComponentRestrictedArrayOfBusinessComponentRestricted :: Maybe [BusinessComponentRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfBusinessComponent__ = ArrayOfBusinessComponent__ {
    businessComponentArrayOfBusinessComponent :: Maybe [BusinessComponent__]
} deriving (Typeable, Eq) 

data BusinessSystemQueryIn__ = BusinessSystemQueryIn__ {
    businessSystemIDBusinessSystemQueryIn :: Maybe CommunicationComponentID__,
    descriptionBusinessSystemQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataBusinessSystemQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data BusinessSystemRestricted__ = BusinessSystemRestricted__ {
    masterLanguageBusinessSystemRestricted :: Maybe String,
    administrativeDataBusinessSystemRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionBusinessSystemRestricted :: Maybe [S0.LONG_Description__],
    businessSystemIDBusinessSystemRestricted :: Maybe CommunicationComponentID__,
    additionalIdentifierBusinessSystemRestricted :: Maybe CommunicationComponentAdditionalIdentifier__,
    assignedUserBusinessSystemRestricted :: Maybe [String]
} deriving (Typeable, Eq) 

data BusinessSystemQueryOut__ = BusinessSystemQueryOut__ {
    businessSystemIDBusinessSystemQueryOut :: Maybe [CommunicationComponentID__],
    logMessageCollectionBusinessSystemQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data BusinessSystemDeleteOpenForEditIn__ = BusinessSystemDeleteOpenForEditIn__ {
    changeListIDBusinessSystemDeleteOpenForEditIn :: Maybe String,
    businessSystemIDBusinessSystemDeleteOpenForEditIn :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data BusinessSystemReadIn__ = BusinessSystemReadIn__ {
    readContextBusinessSystemReadIn :: Maybe String,
    businessSystemIDBusinessSystemReadIn :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data BusinessSystemOpenForEditOut__ = BusinessSystemOpenForEditOut__ {
    changeListIDBusinessSystemOpenForEditOut :: Maybe S0.ChangeListID__,
    businessSystemBusinessSystemOpenForEditOut :: Maybe [BusinessSystem__],
    logMessageCollectionBusinessSystemOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data BusinessSystem__ = BusinessSystem__ {
    masterLanguageBusinessSystem :: Maybe String,
    administrativeDataBusinessSystem :: Maybe S0.ObjectAdministrativeData__,
    descriptionBusinessSystem :: Maybe [S0.LONG_Description__],
    businessSystemIDBusinessSystem :: Maybe CommunicationComponentID__,
    additionalIdentifierBusinessSystem :: Maybe [CommunicationComponentAdditionalIdentifier__],
    isThirdPartyBusinessSystem :: Maybe Bool,
    assignedUserBusinessSystem :: Maybe [String]
} deriving (Typeable, Eq) 

data BusinessSystemReadOut__ = BusinessSystemReadOut__ {
    businessSystemBusinessSystemReadOut :: Maybe [BusinessSystem__],
    logMessageCollectionBusinessSystemReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data BusinessSystemIdentifierCollection__ = BusinessSystemIdentifierCollection__ {
    businessSystemIDBusinessSystemIdentifierCollection :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data BusinessSystemCreateChangeIn__ = BusinessSystemCreateChangeIn__ {
    changeListIDBusinessSystemCreateChangeIn :: Maybe String,
    businessSystemBusinessSystemCreateChangeIn :: Maybe [BusinessSystemRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfBusinessSystemRestricted__ = ArrayOfBusinessSystemRestricted__ {
    businessSystemRestrictedArrayOfBusinessSystemRestricted :: Maybe [BusinessSystemRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfBusinessSystem__ = ArrayOfBusinessSystem__ {
    businessSystemArrayOfBusinessSystem :: Maybe [BusinessSystem__]
} deriving (Typeable, Eq) 

data ChangeListGetObjectIdentifiersOut__ = ChangeListGetObjectIdentifiersOut__ {
    partyIDChangeListGetObjectIdentifiersOut :: Maybe [String],
    businessSystemIDChangeListGetObjectIdentifiersOut :: Maybe [CommunicationComponentID__],
    businessComponentIDChangeListGetObjectIdentifiersOut :: Maybe [CommunicationComponentID__],
    integrationProcessIDChangeListGetObjectIdentifiersOut :: Maybe [CommunicationComponentID__],
    communicationChannelIDChangeListGetObjectIdentifiersOut :: Maybe [CommunicationChannelID__],
    senderAgreementIDChangeListGetObjectIdentifiersOut :: Maybe [MessageHeaderID__],
    receiverAgreementIDChangeListGetObjectIdentifiersOut :: Maybe [MessageHeaderID__],
    receiverDeterminationIDChangeListGetObjectIdentifiersOut :: Maybe [MessageHeaderID__],
    interfaceDeterminationIDChangeListGetObjectIdentifiersOut :: Maybe [MessageHeaderID__],
    valueMappingIDChangeListGetObjectIdentifiersOut :: Maybe [String],
    configurationScenarioIDChangeListGetObjectIdentifiersOut :: Maybe [String],
    logMessageCollectionChangeListGetObjectIdentifiersOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ChangeListGetStateOut__ = ChangeListGetStateOut__ {
    stateChangeListGetStateOut :: Maybe String,
    logMessageCollectionChangeListGetStateOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ChangeListCacheState__ = ChangeListCacheState__ {
    consumerChangeListCacheState :: Maybe String,
    notificationStateChangeListCacheState :: Maybe String,
    refreshStateChangeListCacheState :: Maybe String,
    errorMessageChangeListCacheState :: Maybe [LogMessageItem__]
} deriving (Typeable, Eq) 

data ChangeListCreateOut__ = ChangeListCreateOut__ {
    changeListIDChangeListCreateOut :: Maybe S0.ChangeListID__,
    logMessageCollectionChangeListCreateOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ChangeListGetCacheStateOut__ = ChangeListGetCacheStateOut__ {
    cacheStateChangeListGetCacheStateOut :: Maybe [ChangeListCacheState__],
    logMessageCollectionChangeListGetCacheStateOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ArrayOfCommunicationChannelID__ = ArrayOfCommunicationChannelID__ {
    communicationChannelIDArrayOfCommunicationChannelID :: Maybe [CommunicationChannelID__]
} deriving (Typeable, Eq) 

data ArrayOfMessageHeaderID__ = ArrayOfMessageHeaderID__ {
    messageHeaderIDArrayOfMessageHeaderID :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data ArrayOfChangeListCacheState__ = ArrayOfChangeListCacheState__ {
    changeListCacheStateArrayOfChangeListCacheState :: Maybe [ChangeListCacheState__]
} deriving (Typeable, Eq) 

data ArrayOfLogMessageItem__ = ArrayOfLogMessageItem__ {
    logMessageItemArrayOfLogMessageItem :: Maybe [LogMessageItem__]
} deriving (Typeable, Eq) 

data GenericTableRow__ = GenericTableRow__ {
    valueTableCellGenericTableRow :: Maybe [GenericTableRowTableCell__]
} deriving (Typeable, Eq) 

data GenericTableRowTableCell__ = GenericTableRowTableCell__ {
    columnNameGenericTableRowTableCell :: Maybe String,
    valueGenericTableRowTableCell :: Maybe String
} deriving (Typeable, Eq) 

data CommunicationChannelTemplateBased__ = CommunicationChannelTemplateBased__ {
    masterLanguageCommunicationChannelTemplateBased :: Maybe String,
    administrativeDataCommunicationChannelTemplateBased :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionCommunicationChannelTemplateBased :: Maybe [S0.LONG_Description__],
    communicationChannelIDCommunicationChannelTemplateBased :: Maybe CommunicationChannelID__,
    channelTemplateCommunicationChannelTemplateBased :: Maybe DesignObjectID__,
    adapterEngineNameCommunicationChannelTemplateBased :: Maybe String,
    adapterSpecificAttributeCommunicationChannelTemplateBased :: Maybe [GenericProperty__],
    adapterSpecificTableAttributeCommunicationChannelTemplateBased :: Maybe [GenericPropertyTable__],
    moduleProcessCommunicationChannelTemplateBased :: Maybe ModuleProcess__,
    senderIdentifierCommunicationChannelTemplateBased :: Maybe ChannelAdditionalIdentifier__,
    receiverIdentifierCommunicationChannelTemplateBased :: Maybe ChannelAdditionalIdentifier__
} deriving (Typeable, Eq) 

data GenericProperty__ = GenericProperty__ {
    nameGenericProperty :: Maybe String,
    valueGenericProperty :: Maybe String
} deriving (Typeable, Eq) 

data GenericPropertyTable__ = GenericPropertyTable__ {
    nameGenericPropertyTable :: Maybe String,
    valueTableRowGenericPropertyTable :: Maybe [GenericTableRow__]
} deriving (Typeable, Eq) 

data ModuleProcess__ = ModuleProcess__ {
    processStepModuleProcess :: Maybe [ProcessStep__],
    parameterGroupModuleProcess :: Maybe [ParameterGroup__]
} deriving (Typeable, Eq) 

data ProcessStep__ = ProcessStep__ {
    moduleNameProcessStep :: Maybe String,
    moduleTypeProcessStep :: Maybe String,
    parameterGroupIDProcessStep :: Maybe String
} deriving (Typeable, Eq) 

data ParameterGroup__ = ParameterGroup__ {
    parameterGroupIDParameterGroup :: Maybe String,
    parameterParameterGroup :: Maybe [GenericPropertyRestricted__]
} deriving (Typeable, Eq) 

data GenericPropertyRestricted__ = GenericPropertyRestricted__ {
    nameGenericPropertyRestricted :: Maybe String,
    valueGenericPropertyRestricted :: Maybe String
} deriving (Typeable, Eq) 

data ChannelAdditionalIdentifier__ = ChannelAdditionalIdentifier__ {
    schemeIDChannelAdditionalIdentifier :: Maybe String,
    schemeAgencyIDChannelAdditionalIdentifier :: Maybe String
} deriving (Typeable, Eq) 

data CommunicationChannelQueryOut__ = CommunicationChannelQueryOut__ {
    communicationChannelIDCommunicationChannelQueryOut :: Maybe [CommunicationChannelID__],
    logMessageCollectionCommunicationChannelQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data CommunicationChannelIdentifierCollection__ = CommunicationChannelIdentifierCollection__ {
    communicationChannelIDCommunicationChannelIdentifierCollection :: Maybe [CommunicationChannelID__]
} deriving (Typeable, Eq) 

data CommunicationChannelCreateChangeIn__ = CommunicationChannelCreateChangeIn__ {
    changeListIDCommunicationChannelCreateChangeIn :: Maybe String,
    communicationChannelCommunicationChannelCreateChangeIn :: Maybe [CommunicationChannelRestricted__]
} deriving (Typeable, Eq) 

data CommunicationChannelRestricted__ = CommunicationChannelRestricted__ {
    masterLanguageCommunicationChannelRestricted :: Maybe String,
    administrativeDataCommunicationChannelRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionCommunicationChannelRestricted :: Maybe [S0.LONG_Description__],
    communicationChannelIDCommunicationChannelRestricted :: Maybe CommunicationChannelID__,
    adapterMetadataCommunicationChannelRestricted :: Maybe DesignObjectID__,
    directionCommunicationChannelRestricted :: Maybe String,
    transportProtocolCommunicationChannelRestricted :: Maybe String,
    transportProtocolVersionCommunicationChannelRestricted :: Maybe String,
    messageProtocolCommunicationChannelRestricted :: Maybe String,
    messageProtocolVersionCommunicationChannelRestricted :: Maybe String,
    adapterEngineNameCommunicationChannelRestricted :: Maybe String,
    adapterSpecificAttributeCommunicationChannelRestricted :: Maybe [GenericProperty__],
    adapterSpecificTableAttributeCommunicationChannelRestricted :: Maybe [GenericPropertyTable__],
    moduleProcessCommunicationChannelRestricted :: Maybe ModuleProcess__,
    senderIdentifierCommunicationChannelRestricted :: Maybe ChannelAdditionalIdentifier__,
    receiverIdentifierCommunicationChannelRestricted :: Maybe ChannelAdditionalIdentifier__
} deriving (Typeable, Eq) 

data CommunicationChannelCreateFromTemplateIn__ = CommunicationChannelCreateFromTemplateIn__ {
    changeListIDCommunicationChannelCreateFromTemplateIn :: Maybe String,
    communicationChannelCommunicationChannelCreateFromTemplateIn :: Maybe [CommunicationChannelTemplateBased__]
} deriving (Typeable, Eq) 

data CommunicationChannelReadOut__ = CommunicationChannelReadOut__ {
    communicationChannelCommunicationChannelReadOut :: Maybe [CommunicationChannel__],
    logMessageCollectionCommunicationChannelReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data CommunicationChannel__ = CommunicationChannel__ {
    masterLanguageCommunicationChannel :: Maybe String,
    administrativeDataCommunicationChannel :: Maybe S0.ObjectAdministrativeData__,
    descriptionCommunicationChannel :: Maybe [S0.LONG_Description__],
    communicationChannelIDCommunicationChannel :: Maybe CommunicationChannelID__,
    adapterMetadataCommunicationChannel :: Maybe DesignObjectID__,
    directionCommunicationChannel :: Maybe String,
    transportProtocolCommunicationChannel :: Maybe String,
    transportProtocolVersionCommunicationChannel :: Maybe String,
    messageProtocolCommunicationChannel :: Maybe String,
    messageProtocolVersionCommunicationChannel :: Maybe String,
    adapterEngineNameCommunicationChannel :: Maybe String,
    adapterSpecificAttributeCommunicationChannel :: Maybe [GenericProperty__],
    adapterSpecificTableAttributeCommunicationChannel :: Maybe [GenericPropertyTable__],
    moduleProcessCommunicationChannel :: Maybe ModuleProcess__,
    senderIdentifierCommunicationChannel :: Maybe ChannelAdditionalIdentifier__,
    receiverIdentifierCommunicationChannel :: Maybe ChannelAdditionalIdentifier__
} deriving (Typeable, Eq) 

data CommunicationChannelReadIn__ = CommunicationChannelReadIn__ {
    readContextCommunicationChannelReadIn :: Maybe String,
    communicationChannelIDCommunicationChannelReadIn :: Maybe [CommunicationChannelID__]
} deriving (Typeable, Eq) 

data CommunicationChannelOpenForEditOut__ = CommunicationChannelOpenForEditOut__ {
    changeListIDCommunicationChannelOpenForEditOut :: Maybe S0.ChangeListID__,
    communicationChannelCommunicationChannelOpenForEditOut :: Maybe [CommunicationChannel__],
    logMessageCollectionCommunicationChannelOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data CommunicationChannelQueryIn__ = CommunicationChannelQueryIn__ {
    communicationChannelIDCommunicationChannelQueryIn :: Maybe CommunicationChannelID__,
    descriptionCommunicationChannelQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataCommunicationChannelQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data CommunicationChannelDeleteOpenForEditIn__ = CommunicationChannelDeleteOpenForEditIn__ {
    changeListIDCommunicationChannelDeleteOpenForEditIn :: Maybe String,
    communicationChannelIDCommunicationChannelDeleteOpenForEditIn :: Maybe [CommunicationChannelID__]
} deriving (Typeable, Eq) 

data ArrayOfGenericPropertyRestricted__ = ArrayOfGenericPropertyRestricted__ {
    genericPropertyRestrictedArrayOfGenericPropertyRestricted :: Maybe [GenericPropertyRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfGenericTableRow__ = ArrayOfGenericTableRow__ {
    genericTableRowArrayOfGenericTableRow :: Maybe [GenericTableRow__]
} deriving (Typeable, Eq) 

data ArrayOfGenericPropertyTable__ = ArrayOfGenericPropertyTable__ {
    genericPropertyTableArrayOfGenericPropertyTable :: Maybe [GenericPropertyTable__]
} deriving (Typeable, Eq) 

data ArrayOfCommunicationChannelTemplateBased__ = ArrayOfCommunicationChannelTemplateBased__ {
    communicationChannelTemplateBasedArrayOfCommunicationChannelTemplateBased :: Maybe [CommunicationChannelTemplateBased__]
} deriving (Typeable, Eq) 

data ArrayOfGenericProperty__ = ArrayOfGenericProperty__ {
    genericPropertyArrayOfGenericProperty :: Maybe [GenericProperty__]
} deriving (Typeable, Eq) 

data ArrayOfCommunicationChannelRestricted__ = ArrayOfCommunicationChannelRestricted__ {
    communicationChannelRestrictedArrayOfCommunicationChannelRestricted :: Maybe [CommunicationChannelRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfGenericTableRowTableCell__ = ArrayOfGenericTableRowTableCell__ {
    genericTableRowTableCellArrayOfGenericTableRowTableCell :: Maybe [GenericTableRowTableCell__]
} deriving (Typeable, Eq) 

data ArrayOfCommunicationChannel__ = ArrayOfCommunicationChannel__ {
    communicationChannelArrayOfCommunicationChannel :: Maybe [CommunicationChannel__]
} deriving (Typeable, Eq) 

data ArrayOfParameterGroup__ = ArrayOfParameterGroup__ {
    parameterGroupArrayOfParameterGroup :: Maybe [ParameterGroup__]
} deriving (Typeable, Eq) 

data ArrayOfProcessStep__ = ArrayOfProcessStep__ {
    processStepArrayOfProcessStep :: Maybe [ProcessStep__]
} deriving (Typeable, Eq) 

data PartyQueryIn__ = PartyQueryIn__ {
    partyIDPartyQueryIn :: Maybe String,
    descriptionPartyQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataPartyQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data PartyReadOut__ = PartyReadOut__ {
    partyPartyReadOut :: Maybe [Party__],
    logMessageCollectionPartyReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data Party__ = Party__ {
    masterLanguageParty :: Maybe String,
    administrativeDataParty :: Maybe S0.ObjectAdministrativeData__,
    descriptionParty :: Maybe [S0.LONG_Description__],
    partyIDParty :: Maybe String,
    additionalIdentifierParty :: Maybe [PartyAdditionalIdentifier__]
} deriving (Typeable, Eq) 

data PartyAdditionalIdentifier__ = PartyAdditionalIdentifier__ {
    schemeIDPartyAdditionalIdentifier :: Maybe String,
    schemeAgencyIDPartyAdditionalIdentifier :: Maybe String,
    valuePartyAdditionalIdentifier :: Maybe String
} deriving (Typeable, Eq) 

data PartyRestricted__ = PartyRestricted__ {
    masterLanguagePartyRestricted :: Maybe String,
    administrativeDataPartyRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionPartyRestricted :: Maybe [S0.LONG_Description__],
    partyIDPartyRestricted :: Maybe String,
    additionalIdentifierPartyRestricted :: Maybe [PartyAdditionalIdentifier__]
} deriving (Typeable, Eq) 

data PartyReadIn__ = PartyReadIn__ {
    readContextPartyReadIn :: Maybe String,
    partyIDPartyReadIn :: Maybe [String]
} deriving (Typeable, Eq) 

data PartyIdentifierCollection__ = PartyIdentifierCollection__ {
    partyIDPartyIdentifierCollection :: Maybe [String]
} deriving (Typeable, Eq) 

data PartyOpenForEditOut__ = PartyOpenForEditOut__ {
    changeListIDPartyOpenForEditOut :: Maybe S0.ChangeListID__,
    partyPartyOpenForEditOut :: Maybe [Party__],
    logMessageCollectionPartyOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data PartyQueryOut__ = PartyQueryOut__ {
    partyIDPartyQueryOut :: Maybe [String],
    logMessageCollectionPartyQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data PartyDeleteOpenForEditIn__ = PartyDeleteOpenForEditIn__ {
    changeListIDPartyDeleteOpenForEditIn :: Maybe String,
    partyIDPartyDeleteOpenForEditIn :: Maybe [String]
} deriving (Typeable, Eq) 

data PartyCreateChangeIn__ = PartyCreateChangeIn__ {
    changeListIDPartyCreateChangeIn :: Maybe String,
    partyPartyCreateChangeIn :: Maybe [PartyRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfPartyRestricted__ = ArrayOfPartyRestricted__ {
    partyRestrictedArrayOfPartyRestricted :: Maybe [PartyRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfPartyAdditionalIdentifier__ = ArrayOfPartyAdditionalIdentifier__ {
    partyAdditionalIdentifierArrayOfPartyAdditionalIdentifier :: Maybe [PartyAdditionalIdentifier__]
} deriving (Typeable, Eq) 

data ArrayOfParty__ = ArrayOfParty__ {
    partyArrayOfParty :: Maybe [Party__]
} deriving (Typeable, Eq) 

data ConfigurationScenarioIdentifierCollection__ = ConfigurationScenarioIdentifierCollection__ {
    configurationScenarioIDConfigurationScenarioIdentifierCollection :: Maybe [String]
} deriving (Typeable, Eq) 

data ConfigurationScenarioCreateChangeIn__ = ConfigurationScenarioCreateChangeIn__ {
    changeListIDConfigurationScenarioCreateChangeIn :: Maybe String,
    configurationScenarioConfigurationScenarioCreateChangeIn :: Maybe [ConfigurationScenarioRestricted__]
} deriving (Typeable, Eq) 

data ConfigurationScenarioRestricted__ = ConfigurationScenarioRestricted__ {
    masterLanguageConfigurationScenarioRestricted :: Maybe String,
    administrativeDataConfigurationScenarioRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionConfigurationScenarioRestricted :: Maybe [S0.LONG_Description__],
    configurationScenarioIDConfigurationScenarioRestricted :: Maybe String,
    repositoryScenarioConfigurationScenarioRestricted :: Maybe DesignObjectID__,
    partyConfigurationScenarioRestricted :: Maybe [String],
    businessSystemConfigurationScenarioRestricted :: Maybe [CommunicationComponentID__],
    businessComponentConfigurationScenarioRestricted :: Maybe [CommunicationComponentID__],
    integrationProcessConfigurationScenarioRestricted :: Maybe [CommunicationComponentID__],
    communicationChannelConfigurationScenarioRestricted :: Maybe [CommunicationChannelID__],
    senderAgreementConfigurationScenarioRestricted :: Maybe [MessageHeaderID__],
    receiverAgreementConfigurationScenarioRestricted :: Maybe [MessageHeaderID__],
    receiverDeterminationConfigurationScenarioRestricted :: Maybe [MessageHeaderID__],
    interfaceDeterminationConfigurationScenarioRestricted :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data ConfigurationScenarioReadOut__ = ConfigurationScenarioReadOut__ {
    configurationScenarioConfigurationScenarioReadOut :: Maybe [ConfigurationScenario__],
    logMessageCollectionConfigurationScenarioReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ConfigurationScenario__ = ConfigurationScenario__ {
    masterLanguageConfigurationScenario :: Maybe String,
    administrativeDataConfigurationScenario :: Maybe S0.ObjectAdministrativeData__,
    descriptionConfigurationScenario :: Maybe [S0.LONG_Description__],
    configurationScenarioIDConfigurationScenario :: Maybe String,
    repositoryScenarioConfigurationScenario :: Maybe DesignObjectID__,
    partyConfigurationScenario :: Maybe [String],
    businessSystemConfigurationScenario :: Maybe [CommunicationComponentID__],
    businessComponentConfigurationScenario :: Maybe [CommunicationComponentID__],
    integrationProcessConfigurationScenario :: Maybe [CommunicationComponentID__],
    communicationChannelConfigurationScenario :: Maybe [CommunicationChannelID__],
    senderAgreementConfigurationScenario :: Maybe [MessageHeaderID__],
    receiverAgreementConfigurationScenario :: Maybe [MessageHeaderID__],
    receiverDeterminationConfigurationScenario :: Maybe [MessageHeaderID__],
    interfaceDeterminationConfigurationScenario :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data ConfigurationScenarioReadIn__ = ConfigurationScenarioReadIn__ {
    readContextConfigurationScenarioReadIn :: Maybe String,
    configurationScenarioIDConfigurationScenarioReadIn :: Maybe [String]
} deriving (Typeable, Eq) 

data ConfigurationScenarioDeleteOpenForEditIn__ = ConfigurationScenarioDeleteOpenForEditIn__ {
    changeListIDConfigurationScenarioDeleteOpenForEditIn :: Maybe String,
    configurationScenarioIDConfigurationScenarioDeleteOpenForEditIn :: Maybe [String]
} deriving (Typeable, Eq) 

data ConfigurationScenarioQueryOut__ = ConfigurationScenarioQueryOut__ {
    configurationScenarioIDConfigurationScenarioQueryOut :: Maybe [String],
    logMessageCollectionConfigurationScenarioQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ConfigurationScenarioOpenForEditOut__ = ConfigurationScenarioOpenForEditOut__ {
    changeListIDConfigurationScenarioOpenForEditOut :: Maybe S0.ChangeListID__,
    configurationScenarioConfigurationScenarioOpenForEditOut :: Maybe [ConfigurationScenario__],
    logMessageCollectionConfigurationScenarioOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ConfigurationScenarioQueryIn__ = ConfigurationScenarioQueryIn__ {
    configurationScenarioIDConfigurationScenarioQueryIn :: Maybe String,
    descriptionConfigurationScenarioQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataConfigurationScenarioQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data ArrayOfConfigurationScenarioRestricted__ = ArrayOfConfigurationScenarioRestricted__ {
    configurationScenarioRestrictedArrayOfConfigurationScenarioRestricted :: Maybe [ConfigurationScenarioRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfConfigurationScenario__ = ArrayOfConfigurationScenario__ {
    configurationScenarioArrayOfConfigurationScenario :: Maybe [ConfigurationScenario__]
} deriving (Typeable, Eq) 

data IntegrationProcessRestricted__ = IntegrationProcessRestricted__ {
    masterLanguageIntegrationProcessRestricted :: Maybe String,
    administrativeDataIntegrationProcessRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionIntegrationProcessRestricted :: Maybe [S0.LONG_Description__],
    integrationProcessIDIntegrationProcessRestricted :: Maybe CommunicationComponentID__,
    repositoryIntegrationProcessIntegrationProcessRestricted :: Maybe DesignObjectID__,
    additionalIdentifierIntegrationProcessRestricted :: Maybe [CommunicationComponentAdditionalIdentifier__]
} deriving (Typeable, Eq) 

data IntegrationProcessIdentifierCollection__ = IntegrationProcessIdentifierCollection__ {
    integrationProcessIDIntegrationProcessIdentifierCollection :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data IntegrationProcessCreateChangeIn__ = IntegrationProcessCreateChangeIn__ {
    changeListIDIntegrationProcessCreateChangeIn :: Maybe String,
    integrationProcessIntegrationProcessCreateChangeIn :: Maybe [IntegrationProcessRestricted__]
} deriving (Typeable, Eq) 

data IntegrationProcess__ = IntegrationProcess__ {
    masterLanguageIntegrationProcess :: Maybe String,
    administrativeDataIntegrationProcess :: Maybe S0.ObjectAdministrativeData__,
    descriptionIntegrationProcess :: Maybe [S0.LONG_Description__],
    integrationProcessIDIntegrationProcess :: Maybe CommunicationComponentID__,
    repositoryIntegrationProcessIntegrationProcess :: Maybe DesignObjectID__,
    additionalIdentifierIntegrationProcess :: Maybe [CommunicationComponentAdditionalIdentifier__]
} deriving (Typeable, Eq) 

data IntegrationProcessQueryOut__ = IntegrationProcessQueryOut__ {
    integrationProcessIDIntegrationProcessQueryOut :: Maybe [CommunicationComponentID__],
    logMessageCollectionIntegrationProcessQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data IntegrationProcessDeleteOpenForEditIn__ = IntegrationProcessDeleteOpenForEditIn__ {
    changeListIDIntegrationProcessDeleteOpenForEditIn :: Maybe String,
    integrationProcessIDIntegrationProcessDeleteOpenForEditIn :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data IntegrationProcessReadIn__ = IntegrationProcessReadIn__ {
    readContextIntegrationProcessReadIn :: Maybe String,
    integrationProcessIDIntegrationProcessReadIn :: Maybe [CommunicationComponentID__]
} deriving (Typeable, Eq) 

data IntegrationProcessReadOut__ = IntegrationProcessReadOut__ {
    integrationProcessIntegrationProcessReadOut :: Maybe [IntegrationProcess__],
    logMessageCollectionIntegrationProcessReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data IntegrationProcessQueryIn__ = IntegrationProcessQueryIn__ {
    integrationProcessIDIntegrationProcessQueryIn :: Maybe CommunicationComponentID__,
    descriptionIntegrationProcessQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataIntegrationProcessQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data ArrayOfIntegrationProcessRestricted__ = ArrayOfIntegrationProcessRestricted__ {
    integrationProcessRestrictedArrayOfIntegrationProcessRestricted :: Maybe [IntegrationProcessRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfIntegrationProcess__ = ArrayOfIntegrationProcess__ {
    integrationProcessArrayOfIntegrationProcess :: Maybe [IntegrationProcess__]
} deriving (Typeable, Eq) 

data InterfaceDeterminationOpenForEditOut__ = InterfaceDeterminationOpenForEditOut__ {
    changeListIDInterfaceDeterminationOpenForEditOut :: Maybe S0.ChangeListID__,
    interfaceDeterminationInterfaceDeterminationOpenForEditOut :: Maybe [InterfaceDetermination__],
    logMessageCollectionInterfaceDeterminationOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data InterfaceDetermination__ = InterfaceDetermination__ {
    masterLanguageInterfaceDetermination :: Maybe String,
    administrativeDataInterfaceDetermination :: Maybe S0.ObjectAdministrativeData__,
    descriptionInterfaceDetermination :: Maybe [S0.LONG_Description__],
    interfaceDeterminationIDInterfaceDetermination :: Maybe MessageHeaderID__,
    ruleInterfaceDetermination :: Maybe [InterfaceDeterminationRule__],
    prefixNamespaceMappingInterfaceDetermination :: Maybe [PrefixNamespaceMapping__],
    qualityOfServiceInterfaceDetermination :: Maybe String
} deriving (Typeable, Eq) 

data InterfaceDeterminationRule__ = InterfaceDeterminationRule__ {
    conditionInterfaceDeterminationRule :: Maybe Condition__,
    mappingInterfaceDeterminationRule :: Maybe DesignObjectID__,
    interfaceInterfaceDeterminationRule :: Maybe [DesignObjectID__]
} deriving (Typeable, Eq) 

data Condition__ = Condition__ {
    atomicConditionBlockCondition :: Maybe [AtomicConditionBlock__]
} deriving (Typeable, Eq) 

data AtomicConditionBlock__ = AtomicConditionBlock__ {
    atomicConditionAtomicConditionBlock :: Maybe [AtomicCondition__]
} deriving (Typeable, Eq) 

data AtomicCondition__ = AtomicCondition__ {
    operatorAtomicCondition :: Maybe String,
    leftExtractorAtomicCondition :: Maybe Extractor__,
    rightExtractorAtomicCondition :: Maybe Extractor__
} deriving (Typeable, Eq) 

data Extractor__ = Extractor__ {
    typeIDExtractor :: Maybe String,
    valueExtractor :: Maybe String,
    datatypeExtractor :: Maybe String,
    contextObjectNameExtractor :: Maybe String,
    contextObjectNamespaceExtractor :: Maybe String
} deriving (Typeable, Eq) 

data PrefixNamespaceMapping__ = PrefixNamespaceMapping__ {
    uRIPrefixNamespaceMapping :: Maybe String,
    prefixPrefixNamespaceMapping :: Maybe String
} deriving (Typeable, Eq) 

data InterfaceDeterminationIdentifierCollection__ = InterfaceDeterminationIdentifierCollection__ {
    interfaceDeterminationIDInterfaceDeterminationIdentifierCollection :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data InterfaceDeterminationDeleteOpenForEditIn__ = InterfaceDeterminationDeleteOpenForEditIn__ {
    changeListIDInterfaceDeterminationDeleteOpenForEditIn :: Maybe String,
    interfaceDeterminationIDInterfaceDeterminationDeleteOpenForEditIn :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data InterfaceDeterminationRestricted__ = InterfaceDeterminationRestricted__ {
    masterLanguageInterfaceDeterminationRestricted :: Maybe String,
    administrativeDataInterfaceDeterminationRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionInterfaceDeterminationRestricted :: Maybe [S0.LONG_Description__],
    interfaceDeterminationIDInterfaceDeterminationRestricted :: Maybe MessageHeaderID__,
    ruleInterfaceDeterminationRestricted :: Maybe [InterfaceDeterminationRule__],
    prefixNamespaceMappingInterfaceDeterminationRestricted :: Maybe [PrefixNamespaceMapping__],
    qualityOfServiceInterfaceDeterminationRestricted :: Maybe String
} deriving (Typeable, Eq) 

data InterfaceDeterminationReadIn__ = InterfaceDeterminationReadIn__ {
    readContextInterfaceDeterminationReadIn :: Maybe String,
    interfaceDeterminationIDInterfaceDeterminationReadIn :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data InterfaceDeterminationQueryOut__ = InterfaceDeterminationQueryOut__ {
    interfaceDeterminationIDInterfaceDeterminationQueryOut :: Maybe [MessageHeaderID__],
    logMessageCollectionInterfaceDeterminationQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data InterfaceDeterminationQueryIn__ = InterfaceDeterminationQueryIn__ {
    interfaceDeterminationIDInterfaceDeterminationQueryIn :: Maybe MessageHeaderID__,
    descriptionInterfaceDeterminationQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataInterfaceDeterminationQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data InterfaceDeterminationCreateChangeIn__ = InterfaceDeterminationCreateChangeIn__ {
    changeListIDInterfaceDeterminationCreateChangeIn :: Maybe String,
    interfaceDeterminationInterfaceDeterminationCreateChangeIn :: Maybe [InterfaceDeterminationRestricted__]
} deriving (Typeable, Eq) 

data InterfaceDeterminationReadOut__ = InterfaceDeterminationReadOut__ {
    interfaceDeterminationInterfaceDeterminationReadOut :: Maybe [InterfaceDetermination__],
    logMessageCollectionInterfaceDeterminationReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ArrayOfInterfaceDetermination__ = ArrayOfInterfaceDetermination__ {
    interfaceDeterminationArrayOfInterfaceDetermination :: Maybe [InterfaceDetermination__]
} deriving (Typeable, Eq) 

data ArrayOfAtomicCondition__ = ArrayOfAtomicCondition__ {
    atomicConditionArrayOfAtomicCondition :: Maybe [AtomicCondition__]
} deriving (Typeable, Eq) 

data ArrayOfAtomicConditionBlock__ = ArrayOfAtomicConditionBlock__ {
    atomicConditionBlockArrayOfAtomicConditionBlock :: Maybe [AtomicConditionBlock__]
} deriving (Typeable, Eq) 

data ArrayOfPrefixNamespaceMapping__ = ArrayOfPrefixNamespaceMapping__ {
    prefixNamespaceMappingArrayOfPrefixNamespaceMapping :: Maybe [PrefixNamespaceMapping__]
} deriving (Typeable, Eq) 

data ArrayOfInterfaceDeterminationRule__ = ArrayOfInterfaceDeterminationRule__ {
    interfaceDeterminationRuleArrayOfInterfaceDeterminationRule :: Maybe [InterfaceDeterminationRule__]
} deriving (Typeable, Eq) 

data ArrayOfInterfaceDeterminationRestricted__ = ArrayOfInterfaceDeterminationRestricted__ {
    interfaceDeterminationRestrictedArrayOfInterfaceDeterminationRestricted :: Maybe [InterfaceDeterminationRestricted__]
} deriving (Typeable, Eq) 

data ReceiverAgreementReadIn__ = ReceiverAgreementReadIn__ {
    readContextReceiverAgreementReadIn :: Maybe String,
    receiverAgreementIDReceiverAgreementReadIn :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data ReceiverAgreementQueryIn__ = ReceiverAgreementQueryIn__ {
    receiverAgreementIDReceiverAgreementQueryIn :: Maybe MessageHeaderID__,
    descriptionReceiverAgreementQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataReceiverAgreementQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data ReceiverAgreementDeleteOpenForEditIn__ = ReceiverAgreementDeleteOpenForEditIn__ {
    changeListIDReceiverAgreementDeleteOpenForEditIn :: Maybe String,
    receiverAgreementIDReceiverAgreementDeleteOpenForEditIn :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data HeaderMapping__ = HeaderMapping__ {
    senderHeaderMapping :: Maybe CommunicationPartnerExtractor__,
    receiverHeaderMapping :: Maybe CommunicationPartnerExtractor__
} deriving (Typeable, Eq) 

data CommunicationPartnerExtractor__ = CommunicationPartnerExtractor__ {
    communicationPartyCommunicationPartnerExtractor :: Maybe Extractor__,
    communicationPartySchemaCommunicationPartnerExtractor :: Maybe Extractor__,
    communicationPartyAgencyCommunicationPartnerExtractor :: Maybe Extractor__,
    communicationComponentCommunicationPartnerExtractor :: Maybe Extractor__
} deriving (Typeable, Eq) 

data ReceiverAgreementQueryOut__ = ReceiverAgreementQueryOut__ {
    receiverAgreementIDReceiverAgreementQueryOut :: Maybe [MessageHeaderID__],
    logMessageCollectionReceiverAgreementQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ReceiverAgreementCreateChangeIn__ = ReceiverAgreementCreateChangeIn__ {
    changeListIDReceiverAgreementCreateChangeIn :: Maybe String,
    receiverAgreementReceiverAgreementCreateChangeIn :: Maybe [ReceiverAgreementRestricted__]
} deriving (Typeable, Eq) 

data ReceiverAgreementRestricted__ = ReceiverAgreementRestricted__ {
    masterLanguageReceiverAgreementRestricted :: Maybe String,
    administrativeDataReceiverAgreementRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionReceiverAgreementRestricted :: Maybe [S0.LONG_Description__],
    receiverAgreementIDReceiverAgreementRestricted :: Maybe MessageHeaderID__,
    communicationChannelReceiverAgreementRestricted :: Maybe CommunicationChannelID__,
    adapterSpecificAttributeReceiverAgreementRestricted :: Maybe [GenericProperty__],
    adapterSpecificTableAttributeReceiverAgreementRestricted :: Maybe [GenericPropertyTable__],
    headerMappingReceiverAgreementRestricted :: Maybe HeaderMapping__,
    prefixNamespaceMappingReceiverAgreementRestricted :: Maybe [PrefixNamespaceMapping__]
} deriving (Typeable, Eq) 

data ReceiverAgreementIdentifierCollection__ = ReceiverAgreementIdentifierCollection__ {
    receiverAgreementIDReceiverAgreementIdentifierCollection :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data ReceiverAgreement__ = ReceiverAgreement__ {
    masterLanguageReceiverAgreement :: Maybe String,
    administrativeDataReceiverAgreement :: Maybe S0.ObjectAdministrativeData__,
    descriptionReceiverAgreement :: Maybe [S0.LONG_Description__],
    receiverAgreementIDReceiverAgreement :: Maybe MessageHeaderID__,
    communicationChannelReceiverAgreement :: Maybe CommunicationChannelID__,
    adapterSpecificAttributeReceiverAgreement :: Maybe [GenericProperty__],
    adapterSpecificTableAttributeReceiverAgreement :: Maybe [GenericPropertyTable__],
    headerMappingReceiverAgreement :: Maybe HeaderMapping__,
    prefixNamespaceMappingReceiverAgreement :: Maybe [PrefixNamespaceMapping__]
} deriving (Typeable, Eq) 

data ReceiverAgreementOpenForEditOut__ = ReceiverAgreementOpenForEditOut__ {
    changeListIDReceiverAgreementOpenForEditOut :: Maybe S0.ChangeListID__,
    receiverAgreementReceiverAgreementOpenForEditOut :: Maybe [ReceiverAgreement__],
    logMessageCollectionReceiverAgreementOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ReceiverAgreementReadOut__ = ReceiverAgreementReadOut__ {
    receiverAgreementReceiverAgreementReadOut :: Maybe [ReceiverAgreement__],
    logMessageCollectionReceiverAgreementReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ArrayOfReceiverAgreement__ = ArrayOfReceiverAgreement__ {
    receiverAgreementArrayOfReceiverAgreement :: Maybe [ReceiverAgreement__]
} deriving (Typeable, Eq) 

data ArrayOfReceiverAgreementRestricted__ = ArrayOfReceiverAgreementRestricted__ {
    receiverAgreementRestrictedArrayOfReceiverAgreementRestricted :: Maybe [ReceiverAgreementRestricted__]
} deriving (Typeable, Eq) 

data ReceiverDeterminationQueryIn__ = ReceiverDeterminationQueryIn__ {
    receiverDeterminationIDReceiverDeterminationQueryIn :: Maybe MessageHeaderID__,
    descriptionReceiverDeterminationQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataReceiverDeterminationQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data ReceiverDeterminationReadIn__ = ReceiverDeterminationReadIn__ {
    readContextReceiverDeterminationReadIn :: Maybe String,
    receiverDeterminationIDReceiverDeterminationReadIn :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data ReceiverDeterminationOpenForEditOut__ = ReceiverDeterminationOpenForEditOut__ {
    changeListIDReceiverDeterminationOpenForEditOut :: Maybe S0.ChangeListID__,
    receiverDeterminationReceiverDeterminationOpenForEditOut :: Maybe [ReceiverDetermination__],
    logMessageCollectionReceiverDeterminationOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ReceiverDetermination__ = ReceiverDetermination__ {
    masterLanguageReceiverDetermination :: Maybe String,
    administrativeDataReceiverDetermination :: Maybe S0.ObjectAdministrativeData__,
    descriptionReceiverDetermination :: Maybe [S0.LONG_Description__],
    receiverDeterminationIDReceiverDetermination :: Maybe MessageHeaderID__,
    ruleReceiverDetermination :: Maybe [ReceiverDeterminationRule__],
    receiverRuleReceiverDetermination :: Maybe [String],
    dynamicReceiverRuleReceiverDetermination :: Maybe [ReceiverDeterminationMapping__],
    prefixNamespaceMappingReceiverDetermination :: Maybe [PrefixNamespaceMapping__],
    noReceiverBehaviourReceiverDetermination :: Maybe String,
    noReceiverReceiverReceiverDetermination :: Maybe CommunicationPartnerExtractor__
} deriving (Typeable, Eq) 

data ReceiverDeterminationRule__ = ReceiverDeterminationRule__ {
    conditionReceiverDeterminationRule :: Maybe Condition__,
    receiverReceiverDeterminationRule :: Maybe [CommunicationPartnerExtractor__]
} deriving (Typeable, Eq) 

data ReceiverDeterminationMapping__ = ReceiverDeterminationMapping__ {
    mappingReceiverDeterminationMapping :: Maybe DesignObjectID__
} deriving (Typeable, Eq) 

data ReceiverDeterminationDeleteOpenForEditIn__ = ReceiverDeterminationDeleteOpenForEditIn__ {
    changeListIDReceiverDeterminationDeleteOpenForEditIn :: Maybe String,
    receiverDeterminationIDReceiverDeterminationDeleteOpenForEditIn :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data ReceiverDeterminationCreateChangeIn__ = ReceiverDeterminationCreateChangeIn__ {
    changeListIDReceiverDeterminationCreateChangeIn :: Maybe String,
    receiverDeterminationReceiverDeterminationCreateChangeIn :: Maybe [ReceiverDeterminationRestricted__]
} deriving (Typeable, Eq) 

data ReceiverDeterminationRestricted__ = ReceiverDeterminationRestricted__ {
    masterLanguageReceiverDeterminationRestricted :: Maybe String,
    administrativeDataReceiverDeterminationRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionReceiverDeterminationRestricted :: Maybe [S0.LONG_Description__],
    receiverDeterminationIDReceiverDeterminationRestricted :: Maybe MessageHeaderID__,
    ruleReceiverDeterminationRestricted :: Maybe [ReceiverDeterminationRule__],
    dynamicReceiverRuleReceiverDeterminationRestricted :: Maybe [ReceiverDeterminationMapping__],
    prefixNamespaceMappingReceiverDeterminationRestricted :: Maybe [PrefixNamespaceMapping__],
    noReceiverBehaviourReceiverDeterminationRestricted :: Maybe String,
    noReceiverReceiverReceiverDeterminationRestricted :: Maybe CommunicationPartnerExtractor__
} deriving (Typeable, Eq) 

data ReceiverDeterminationIdentifierCollection__ = ReceiverDeterminationIdentifierCollection__ {
    receiverDeterminationIDReceiverDeterminationIdentifierCollection :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data ReceiverDeterminationQueryOut__ = ReceiverDeterminationQueryOut__ {
    receiverDeterminationIDReceiverDeterminationQueryOut :: Maybe [MessageHeaderID__],
    logMessageCollectionReceiverDeterminationQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ReceiverDeterminationReadOut__ = ReceiverDeterminationReadOut__ {
    receiverDeterminationReceiverDeterminationReadOut :: Maybe [ReceiverDetermination__],
    logMessageCollectionReceiverDeterminationReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ArrayOfReceiverDeterminationRestricted__ = ArrayOfReceiverDeterminationRestricted__ {
    receiverDeterminationRestrictedArrayOfReceiverDeterminationRestricted :: Maybe [ReceiverDeterminationRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfCommunicationPartnerExtractor__ = ArrayOfCommunicationPartnerExtractor__ {
    communicationPartnerExtractorArrayOfCommunicationPartnerExtractor :: Maybe [CommunicationPartnerExtractor__]
} deriving (Typeable, Eq) 

data ArrayOfReceiverDeterminationMapping__ = ArrayOfReceiverDeterminationMapping__ {
    receiverDeterminationMappingArrayOfReceiverDeterminationMapping :: Maybe [ReceiverDeterminationMapping__]
} deriving (Typeable, Eq) 

data ArrayOfReceiverDetermination__ = ArrayOfReceiverDetermination__ {
    receiverDeterminationArrayOfReceiverDetermination :: Maybe [ReceiverDetermination__]
} deriving (Typeable, Eq) 

data ArrayOfReceiverDeterminationRule__ = ArrayOfReceiverDeterminationRule__ {
    receiverDeterminationRuleArrayOfReceiverDeterminationRule :: Maybe [ReceiverDeterminationRule__]
} deriving (Typeable, Eq) 

data SenderAgreementQueryOut__ = SenderAgreementQueryOut__ {
    senderAgreementIDSenderAgreementQueryOut :: Maybe [MessageHeaderID__],
    logMessageCollectionSenderAgreementQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data SenderAgreementQueryIn__ = SenderAgreementQueryIn__ {
    senderAgreementIDSenderAgreementQueryIn :: Maybe MessageHeaderID__,
    descriptionSenderAgreementQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataSenderAgreementQueryIn :: Maybe S0.ObjectAdministrativeData__
} deriving (Typeable, Eq) 

data SenderAgreement__ = SenderAgreement__ {
    masterLanguageSenderAgreement :: Maybe String,
    administrativeDataSenderAgreement :: Maybe S0.ObjectAdministrativeData__,
    descriptionSenderAgreement :: Maybe [S0.LONG_Description__],
    senderAgreementIDSenderAgreement :: Maybe MessageHeaderID__,
    communicationChannelSenderAgreement :: Maybe CommunicationChannelID__,
    adapterSpecificAttributeSenderAgreement :: Maybe [GenericProperty__],
    adapterSpecificTableAttributeSenderAgreement :: Maybe [GenericPropertyTable__],
    assignedUserSenderAgreement :: Maybe [String]
} deriving (Typeable, Eq) 

data SenderAgreementDeleteOpenForEditIn__ = SenderAgreementDeleteOpenForEditIn__ {
    changeListIDSenderAgreementDeleteOpenForEditIn :: Maybe String,
    senderAgreementIDSenderAgreementDeleteOpenForEditIn :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data SenderAgreementRestricted__ = SenderAgreementRestricted__ {
    masterLanguageSenderAgreementRestricted :: Maybe String,
    administrativeDataSenderAgreementRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionSenderAgreementRestricted :: Maybe [S0.LONG_Description__],
    senderAgreementIDSenderAgreementRestricted :: Maybe MessageHeaderID__,
    communicationChannelSenderAgreementRestricted :: Maybe CommunicationChannelID__,
    adapterSpecificAttributeSenderAgreementRestricted :: Maybe [GenericProperty__],
    adapterSpecificTableAttributeSenderAgreementRestricted :: Maybe [GenericPropertyTable__],
    assignedUserSenderAgreementRestricted :: Maybe [String]
} deriving (Typeable, Eq) 

data SenderAgreementReadIn__ = SenderAgreementReadIn__ {
    readContextSenderAgreementReadIn :: Maybe String,
    senderAgreementIDSenderAgreementReadIn :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data SenderAgreementIdentifierCollection__ = SenderAgreementIdentifierCollection__ {
    senderAgreementIDSenderAgreementIdentifierCollection :: Maybe [MessageHeaderID__]
} deriving (Typeable, Eq) 

data SenderAgreementReadOut__ = SenderAgreementReadOut__ {
    senderAgreementSenderAgreementReadOut :: Maybe [SenderAgreement__],
    logMessageCollectionSenderAgreementReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data SenderAgreementOpenForEditOut__ = SenderAgreementOpenForEditOut__ {
    changeListIDSenderAgreementOpenForEditOut :: Maybe S0.ChangeListID__,
    senderAgreementSenderAgreementOpenForEditOut :: Maybe [SenderAgreement__],
    logMessageCollectionSenderAgreementOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data SenderAgreementCreateChangeIn__ = SenderAgreementCreateChangeIn__ {
    changeListIDSenderAgreementCreateChangeIn :: Maybe String,
    senderAgreementSenderAgreementCreateChangeIn :: Maybe [SenderAgreementRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfSenderAgreementRestricted__ = ArrayOfSenderAgreementRestricted__ {
    senderAgreementRestrictedArrayOfSenderAgreementRestricted :: Maybe [SenderAgreementRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfSenderAgreement__ = ArrayOfSenderAgreement__ {
    senderAgreementArrayOfSenderAgreement :: Maybe [SenderAgreement__]
} deriving (Typeable, Eq) 

data ValueMappingRestricted__ = ValueMappingRestricted__ {
    masterLanguageValueMappingRestricted :: Maybe String,
    administrativeDataValueMappingRestricted :: Maybe S0.ObjectAdministrativeDataRestricted__,
    descriptionValueMappingRestricted :: Maybe [S0.LONG_Description__],
    valueMappingIDValueMappingRestricted :: Maybe String,
    groupNameValueMappingRestricted :: Maybe String,
    representationValueMappingRestricted :: Maybe [ValueMappingRepresentation__]
} deriving (Typeable, Eq) 

data ValueMappingRepresentation__ = ValueMappingRepresentation__ {
    schemeIDValueMappingRepresentation :: Maybe String,
    schemeAgencyIDValueMappingRepresentation :: Maybe String,
    valueValueMappingRepresentation :: Maybe String
} deriving (Typeable, Eq) 

data ValueMappingQueryIn__ = ValueMappingQueryIn__ {
    valueMappingIDValueMappingQueryIn :: Maybe String,
    descriptionValueMappingQueryIn :: Maybe S0.LONG_Description__,
    administrativeDataValueMappingQueryIn :: Maybe S0.ObjectAdministrativeData__,
    groupNameValueMappingQueryIn :: Maybe String,
    representationValueMappingQueryIn :: Maybe ValueMappingRepresentation__
} deriving (Typeable, Eq) 

data ValueMappingReadOut__ = ValueMappingReadOut__ {
    valueMappingValueMappingReadOut :: Maybe [ValueMapping__],
    logMessageCollectionValueMappingReadOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ValueMapping__ = ValueMapping__ {
    masterLanguageValueMapping :: Maybe String,
    administrativeDataValueMapping :: Maybe S0.ObjectAdministrativeData__,
    descriptionValueMapping :: Maybe [S0.LONG_Description__],
    valueMappingIDValueMapping :: Maybe String,
    groupNameValueMapping :: Maybe String,
    representationValueMapping :: Maybe [ValueMappingRepresentation__]
} deriving (Typeable, Eq) 

data ValueMappingQueryOut__ = ValueMappingQueryOut__ {
    valueMappingIDValueMappingQueryOut :: Maybe [String],
    logMessageCollectionValueMappingQueryOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ValueMappingIdentifierCollection__ = ValueMappingIdentifierCollection__ {
    valueMappingIDValueMappingIdentifierCollection :: Maybe [String]
} deriving (Typeable, Eq) 

data ValueMappingReadIn__ = ValueMappingReadIn__ {
    readContextValueMappingReadIn :: Maybe String,
    valueMappingIDValueMappingReadIn :: Maybe [String]
} deriving (Typeable, Eq) 

data ValueMappingDeleteOpenForEditIn__ = ValueMappingDeleteOpenForEditIn__ {
    changeListIDValueMappingDeleteOpenForEditIn :: Maybe String,
    valueMappingIDValueMappingDeleteOpenForEditIn :: Maybe [String]
} deriving (Typeable, Eq) 

data ValueMappingCreateChangeIn__ = ValueMappingCreateChangeIn__ {
    changeListIDValueMappingCreateChangeIn :: Maybe String,
    valueMappingValueMappingCreateChangeIn :: Maybe [ValueMappingRestricted__]
} deriving (Typeable, Eq) 

data ValueMappingOpenForEditOut__ = ValueMappingOpenForEditOut__ {
    changeListIDValueMappingOpenForEditOut :: Maybe S0.ChangeListID__,
    valueMappingValueMappingOpenForEditOut :: Maybe [ValueMapping__],
    logMessageCollectionValueMappingOpenForEditOut :: Maybe LogMessageCollection__
} deriving (Typeable, Eq) 

data ArrayOfValueMappingRestricted__ = ArrayOfValueMappingRestricted__ {
    valueMappingRestrictedArrayOfValueMappingRestricted :: Maybe [ValueMappingRestricted__]
} deriving (Typeable, Eq) 

data ArrayOfValueMapping__ = ArrayOfValueMapping__ {
    valueMappingArrayOfValueMapping :: Maybe [ValueMapping__]
} deriving (Typeable, Eq) 

data ArrayOfValueMappingRepresentation__ = ArrayOfValueMappingRepresentation__ {
    valueMappingRepresentationArrayOfValueMappingRepresentation :: Maybe [ValueMappingRepresentation__]
} deriving (Typeable, Eq) 



-- instances


instance Xmlable LogMessageItem__ where
	toContent x = [makeToContent ["tns:SeverityCode", "tns:ClassificationCode", "tns:Message"] [toContent.severityCodeLogMessageItem, toContent.classificationCodeLogMessageItem, toContent.messageLogMessageItem] x]
	fromContent cs = LogMessageItem__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:SeverityCode", "tns:ClassificationCode", "tns:Message"] cs

instance Xmlable Text__ where
	toContent x = [makeToContent ["tns:languageCode", "tns:value"] [toContent.languageCodeText, toContent.valueText] x]
	fromContent cs = Text__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:languageCode", "tns:value"] cs

instance Xmlable LogMessageCommunicationChannel__ where
	toContent x = [makeToContent ["tns:CommunicationChannelID", "tns:LogMessageItem"] [toContent.communicationChannelIDLogMessageCommunicationChannel, toContent.logMessageItemLogMessageCommunicationChannel] x]
	fromContent cs = LogMessageCommunicationChannel__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:CommunicationChannelID", "tns:LogMessageItem"] cs

instance Xmlable CommunicationChannelID__ where
	toContent x = [makeToContent ["tns:PartyID", "tns:ComponentID", "tns:ChannelID"] [toContent.partyIDCommunicationChannelID, toContent.componentIDCommunicationChannelID, toContent.channelIDCommunicationChannelID] x]
	fromContent cs = CommunicationChannelID__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:PartyID", "tns:ComponentID", "tns:ChannelID"] cs

instance Xmlable BusinessComponentIdentifierCollection__ where
	toContent x = [makeToContent ["tns:BusinessComponentID"] [toContent.businessComponentIDBusinessComponentIdentifierCollection] x]
	fromContent cs = BusinessComponentIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:BusinessComponentID"] cs

instance Xmlable CommunicationComponentID__ where
	toContent x = [makeToContent ["tns:PartyID", "tns:ComponentID"] [toContent.partyIDCommunicationComponentID, toContent.componentIDCommunicationComponentID] x]
	fromContent cs = CommunicationComponentID__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:PartyID", "tns:ComponentID"] cs

instance Xmlable LogMessageMessageHeader__ where
	toContent x = [makeToContent ["tns:MessageHeader", "tns:LogMessageItem"] [toContent.messageHeaderLogMessageMessageHeader, toContent.logMessageItemLogMessageMessageHeader] x]
	fromContent cs = LogMessageMessageHeader__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:MessageHeader", "tns:LogMessageItem"] cs

instance Xmlable MessageHeaderID__ where
	toContent x = [makeToContent ["tns:SenderPartyID", "tns:SenderComponentID", "tns:InterfaceName", "tns:InterfaceNamespace", "tns:ReceiverPartyID", "tns:ReceiverComponentID"] [toContent.senderPartyIDMessageHeaderID, toContent.senderComponentIDMessageHeaderID, toContent.interfaceNameMessageHeaderID, toContent.interfaceNamespaceMessageHeaderID, toContent.receiverPartyIDMessageHeaderID, toContent.receiverComponentIDMessageHeaderID] x]
	fromContent cs = MessageHeaderID__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6)
		where [c1, c2, c3, c4, c5, c6] = forFromContent nss ["tns:SenderPartyID", "tns:SenderComponentID", "tns:InterfaceName", "tns:InterfaceNamespace", "tns:ReceiverPartyID", "tns:ReceiverComponentID"] cs

instance Xmlable LogMessageConfigurationScenario__ where
	toContent x = [makeToContent ["tns:ConfigurationScenarioID", "tns:LogMessageItem"] [toContent.configurationScenarioIDLogMessageConfigurationScenario, toContent.logMessageItemLogMessageConfigurationScenario] x]
	fromContent cs = LogMessageConfigurationScenario__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ConfigurationScenarioID", "tns:LogMessageItem"] cs

instance Xmlable LogMessageParty__ where
	toContent x = [makeToContent ["tns:PartyID", "tns:LogMessageItem"] [toContent.partyIDLogMessageParty, toContent.logMessageItemLogMessageParty] x]
	fromContent cs = LogMessageParty__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:PartyID", "tns:LogMessageItem"] cs

instance Xmlable BusinessComponentOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:BusinessComponent", "tns:LogMessageCollection"] [toContent.changeListIDBusinessComponentOpenForEditOut, toContent.businessComponentBusinessComponentOpenForEditOut, toContent.logMessageCollectionBusinessComponentOpenForEditOut] x]
	fromContent cs = BusinessComponentOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:BusinessComponent", "tns:LogMessageCollection"] cs

instance Xmlable BusinessComponent__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:BusinessComponentID", "tns:InboundInterface", "tns:OutboundInterface", "tns:AdditionalIdentifier", "tns:IsThirdParty", "tns:AssignedUser"] [toContent.masterLanguageBusinessComponent, toContent.administrativeDataBusinessComponent, toContent.descriptionBusinessComponent, toContent.businessComponentIDBusinessComponent, toContent.inboundInterfaceBusinessComponent, toContent.outboundInterfaceBusinessComponent, toContent.additionalIdentifierBusinessComponent, toContent.isThirdPartyBusinessComponent, toContent.assignedUserBusinessComponent] x]
	fromContent cs = BusinessComponent__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:BusinessComponentID", "tns:InboundInterface", "tns:OutboundInterface", "tns:AdditionalIdentifier", "tns:IsThirdParty", "tns:AssignedUser"] cs

instance Xmlable DesignObjectID__ where
	toContent x = [makeToContent ["tns:Name", "tns:Namespace", "tns:SoftwareComponentVersionID"] [toContent.nameDesignObjectID, toContent.namespaceDesignObjectID, toContent.softwareComponentVersionIDDesignObjectID] x]
	fromContent cs = DesignObjectID__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:Name", "tns:Namespace", "tns:SoftwareComponentVersionID"] cs

instance Xmlable CommunicationComponentAdditionalIdentifier__ where
	toContent x = [makeToContent ["tns:schemeID", "tns:value"] [toContent.schemeIDCommunicationComponentAdditionalIdentifier, toContent.valueCommunicationComponentAdditionalIdentifier] x]
	fromContent cs = CommunicationComponentAdditionalIdentifier__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:schemeID", "tns:value"] cs

instance Xmlable LogMessageCollection__ where
	toContent x = [makeToContent ["tns:LogMessage", "tns:LogMessageChangeList", "tns:LogMessageParty", "tns:LogMessageBusinessSystem", "tns:LogMessageBusinessComponent", "tns:LogMessageIntegrationProcess", "tns:LogMessageCommunicationChannel", "tns:LogMessageSenderAgreement", "tns:LogMessageReceiverAgreement", "tns:LogMessageInterfaceDetermination", "tns:LogMessageReceiverDetermination", "tns:LogMessageValueMapping", "tns:LogMessageConfigurationScenario"] [toContent.logMessageLogMessageCollection, toContent.logMessageChangeListLogMessageCollection, toContent.logMessagePartyLogMessageCollection, toContent.logMessageBusinessSystemLogMessageCollection, toContent.logMessageBusinessComponentLogMessageCollection, toContent.logMessageIntegrationProcessLogMessageCollection, toContent.logMessageCommunicationChannelLogMessageCollection, toContent.logMessageSenderAgreementLogMessageCollection, toContent.logMessageReceiverAgreementLogMessageCollection, toContent.logMessageInterfaceDeterminationLogMessageCollection, toContent.logMessageReceiverDeterminationLogMessageCollection, toContent.logMessageValueMappingLogMessageCollection, toContent.logMessageConfigurationScenarioLogMessageCollection] x]
	fromContent cs = LogMessageCollection__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9) (fromContent c10) (fromContent c11) (fromContent c12) (fromContent c13)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13] = forFromContent nss ["tns:LogMessage", "tns:LogMessageChangeList", "tns:LogMessageParty", "tns:LogMessageBusinessSystem", "tns:LogMessageBusinessComponent", "tns:LogMessageIntegrationProcess", "tns:LogMessageCommunicationChannel", "tns:LogMessageSenderAgreement", "tns:LogMessageReceiverAgreement", "tns:LogMessageInterfaceDetermination", "tns:LogMessageReceiverDetermination", "tns:LogMessageValueMapping", "tns:LogMessageConfigurationScenario"] cs

instance Xmlable LogMessage__ where
	toContent x = [makeToContent ["tns:LogMessageItem"] [toContent.logMessageItemLogMessage] x]
	fromContent cs = LogMessage__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessageItem"] cs

instance Xmlable LogMessageChangeList__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:LogMessageItem"] [toContent.changeListIDLogMessageChangeList, toContent.logMessageItemLogMessageChangeList] x]
	fromContent cs = LogMessageChangeList__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:LogMessageItem"] cs

instance Xmlable LogMessageCommunicationComponent__ where
	toContent x = [makeToContent ["tns:CommunicationComponentID", "tns:LogMessageItem"] [toContent.communicationComponentIDLogMessageCommunicationComponent, toContent.logMessageItemLogMessageCommunicationComponent] x]
	fromContent cs = LogMessageCommunicationComponent__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:CommunicationComponentID", "tns:LogMessageItem"] cs

instance Xmlable LogMessageValueMapping__ where
	toContent x = [makeToContent ["tns:ValueMappingID", "tns:LogMessageItem"] [toContent.valueMappingIDLogMessageValueMapping, toContent.logMessageItemLogMessageValueMapping] x]
	fromContent cs = LogMessageValueMapping__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ValueMappingID", "tns:LogMessageItem"] cs

instance Xmlable BusinessComponentRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:BusinessComponentID", "tns:InboundInterface", "tns:OutboundInterface", "tns:AdditionalIdentifier", "tns:IsThirdParty", "tns:AssignedUser"] [toContent.masterLanguageBusinessComponentRestricted, toContent.administrativeDataBusinessComponentRestricted, toContent.descriptionBusinessComponentRestricted, toContent.businessComponentIDBusinessComponentRestricted, toContent.inboundInterfaceBusinessComponentRestricted, toContent.outboundInterfaceBusinessComponentRestricted, toContent.additionalIdentifierBusinessComponentRestricted, toContent.isThirdPartyBusinessComponentRestricted, toContent.assignedUserBusinessComponentRestricted] x]
	fromContent cs = BusinessComponentRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:BusinessComponentID", "tns:InboundInterface", "tns:OutboundInterface", "tns:AdditionalIdentifier", "tns:IsThirdParty", "tns:AssignedUser"] cs

instance Xmlable BusinessComponentDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:BusinessComponentID"] [toContent.changeListIDBusinessComponentDeleteOpenForEditIn, toContent.businessComponentIDBusinessComponentDeleteOpenForEditIn] x]
	fromContent cs = BusinessComponentDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:BusinessComponentID"] cs

instance Xmlable ConfigurationObjectModifyOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:LogMessageCollection"] [toContent.changeListIDConfigurationObjectModifyOut, toContent.logMessageCollectionConfigurationObjectModifyOut] x]
	fromContent cs = ConfigurationObjectModifyOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:LogMessageCollection"] cs

instance Xmlable BusinessComponentQueryIn__ where
	toContent x = [makeToContent ["tns:BusinessComponentID", "tns:Description", "tns:AdministrativeData"] [toContent.businessComponentIDBusinessComponentQueryIn, toContent.descriptionBusinessComponentQueryIn, toContent.administrativeDataBusinessComponentQueryIn] x]
	fromContent cs = BusinessComponentQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:BusinessComponentID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable BusinessComponentQueryOut__ where
	toContent x = [makeToContent ["tns:BusinessComponentID", "tns:LogMessageCollection"] [toContent.businessComponentIDBusinessComponentQueryOut, toContent.logMessageCollectionBusinessComponentQueryOut] x]
	fromContent cs = BusinessComponentQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:BusinessComponentID", "tns:LogMessageCollection"] cs

instance Xmlable BusinessComponentCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:BusinessComponent"] [toContent.changeListIDBusinessComponentCreateChangeIn, toContent.businessComponentBusinessComponentCreateChangeIn] x]
	fromContent cs = BusinessComponentCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:BusinessComponent"] cs

instance Xmlable BusinessComponentReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:BusinessComponentID"] [toContent.readContextBusinessComponentReadIn, toContent.businessComponentIDBusinessComponentReadIn] x]
	fromContent cs = BusinessComponentReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:BusinessComponentID"] cs

instance Xmlable BusinessComponentReadOut__ where
	toContent x = [makeToContent ["tns:BusinessComponent", "tns:LogMessageCollection"] [toContent.businessComponentBusinessComponentReadOut, toContent.logMessageCollectionBusinessComponentReadOut] x]
	fromContent cs = BusinessComponentReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:BusinessComponent", "tns:LogMessageCollection"] cs

instance Xmlable ArrayOfLogMessageParty__ where
	toContent x = [makeToContent ["tns:LogMessageParty"] [toContent.logMessagePartyArrayOfLogMessageParty] x]
	fromContent cs = ArrayOfLogMessageParty__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessageParty"] cs

instance Xmlable ArrayOfLogMessageConfigurationScenario__ where
	toContent x = [makeToContent ["tns:LogMessageConfigurationScenario"] [toContent.logMessageConfigurationScenarioArrayOfLogMessageConfigurationScenario] x]
	fromContent cs = ArrayOfLogMessageConfigurationScenario__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessageConfigurationScenario"] cs

instance Xmlable ArrayOfLogMessage__ where
	toContent x = [makeToContent ["tns:LogMessage"] [toContent.logMessageArrayOfLogMessage] x]
	fromContent cs = ArrayOfLogMessage__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessage"] cs

instance Xmlable ArrayOfCommunicationComponentID__ where
	toContent x = [makeToContent ["tns:CommunicationComponentID"] [toContent.communicationComponentIDArrayOfCommunicationComponentID] x]
	fromContent cs = ArrayOfCommunicationComponentID__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:CommunicationComponentID"] cs

instance Xmlable ArrayOfLogMessageMessageHeader__ where
	toContent x = [makeToContent ["tns:LogMessageMessageHeader"] [toContent.logMessageMessageHeaderArrayOfLogMessageMessageHeader] x]
	fromContent cs = ArrayOfLogMessageMessageHeader__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessageMessageHeader"] cs

instance Xmlable ArrayOfLogMessageValueMapping__ where
	toContent x = [makeToContent ["tns:LogMessageValueMapping"] [toContent.logMessageValueMappingArrayOfLogMessageValueMapping] x]
	fromContent cs = ArrayOfLogMessageValueMapping__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessageValueMapping"] cs

instance Xmlable ArrayOfCommunicationComponentAdditionalIdentifier__ where
	toContent x = [makeToContent ["tns:CommunicationComponentAdditionalIdentifier"] [toContent.communicationComponentAdditionalIdentifierArrayOfCommunicationComponentAdditionalIdentifier] x]
	fromContent cs = ArrayOfCommunicationComponentAdditionalIdentifier__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:CommunicationComponentAdditionalIdentifier"] cs

instance Xmlable ArrayOfLogMessageCommunicationChannel__ where
	toContent x = [makeToContent ["tns:LogMessageCommunicationChannel"] [toContent.logMessageCommunicationChannelArrayOfLogMessageCommunicationChannel] x]
	fromContent cs = ArrayOfLogMessageCommunicationChannel__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessageCommunicationChannel"] cs

instance Xmlable ArrayOfLogMessageCommunicationComponent__ where
	toContent x = [makeToContent ["tns:LogMessageCommunicationComponent"] [toContent.logMessageCommunicationComponentArrayOfLogMessageCommunicationComponent] x]
	fromContent cs = ArrayOfLogMessageCommunicationComponent__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessageCommunicationComponent"] cs

instance Xmlable ArrayOfLogMessageChangeList__ where
	toContent x = [makeToContent ["tns:LogMessageChangeList"] [toContent.logMessageChangeListArrayOfLogMessageChangeList] x]
	fromContent cs = ArrayOfLogMessageChangeList__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessageChangeList"] cs

instance Xmlable ArrayOfDesignObjectID__ where
	toContent x = [makeToContent ["tns:DesignObjectID"] [toContent.designObjectIDArrayOfDesignObjectID] x]
	fromContent cs = ArrayOfDesignObjectID__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:DesignObjectID"] cs

instance Xmlable ArrayOfBusinessComponentRestricted__ where
	toContent x = [makeToContent ["tns:BusinessComponentRestricted"] [toContent.businessComponentRestrictedArrayOfBusinessComponentRestricted] x]
	fromContent cs = ArrayOfBusinessComponentRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:BusinessComponentRestricted"] cs

instance Xmlable ArrayOfBusinessComponent__ where
	toContent x = [makeToContent ["tns:BusinessComponent"] [toContent.businessComponentArrayOfBusinessComponent] x]
	fromContent cs = ArrayOfBusinessComponent__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:BusinessComponent"] cs

instance Xmlable BusinessSystemQueryIn__ where
	toContent x = [makeToContent ["tns:BusinessSystemID", "tns:Description", "tns:AdministrativeData"] [toContent.businessSystemIDBusinessSystemQueryIn, toContent.descriptionBusinessSystemQueryIn, toContent.administrativeDataBusinessSystemQueryIn] x]
	fromContent cs = BusinessSystemQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:BusinessSystemID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable BusinessSystemRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:BusinessSystemID", "tns:AdditionalIdentifier", "tns:AssignedUser"] [toContent.masterLanguageBusinessSystemRestricted, toContent.administrativeDataBusinessSystemRestricted, toContent.descriptionBusinessSystemRestricted, toContent.businessSystemIDBusinessSystemRestricted, toContent.additionalIdentifierBusinessSystemRestricted, toContent.assignedUserBusinessSystemRestricted] x]
	fromContent cs = BusinessSystemRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6)
		where [c1, c2, c3, c4, c5, c6] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:BusinessSystemID", "tns:AdditionalIdentifier", "tns:AssignedUser"] cs

instance Xmlable BusinessSystemQueryOut__ where
	toContent x = [makeToContent ["tns:BusinessSystemID", "tns:LogMessageCollection"] [toContent.businessSystemIDBusinessSystemQueryOut, toContent.logMessageCollectionBusinessSystemQueryOut] x]
	fromContent cs = BusinessSystemQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:BusinessSystemID", "tns:LogMessageCollection"] cs

instance Xmlable BusinessSystemDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:BusinessSystemID"] [toContent.changeListIDBusinessSystemDeleteOpenForEditIn, toContent.businessSystemIDBusinessSystemDeleteOpenForEditIn] x]
	fromContent cs = BusinessSystemDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:BusinessSystemID"] cs

instance Xmlable BusinessSystemReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:BusinessSystemID"] [toContent.readContextBusinessSystemReadIn, toContent.businessSystemIDBusinessSystemReadIn] x]
	fromContent cs = BusinessSystemReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:BusinessSystemID"] cs

instance Xmlable BusinessSystemOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:BusinessSystem", "tns:LogMessageCollection"] [toContent.changeListIDBusinessSystemOpenForEditOut, toContent.businessSystemBusinessSystemOpenForEditOut, toContent.logMessageCollectionBusinessSystemOpenForEditOut] x]
	fromContent cs = BusinessSystemOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:BusinessSystem", "tns:LogMessageCollection"] cs

instance Xmlable BusinessSystem__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:BusinessSystemID", "tns:AdditionalIdentifier", "tns:IsThirdParty", "tns:AssignedUser"] [toContent.masterLanguageBusinessSystem, toContent.administrativeDataBusinessSystem, toContent.descriptionBusinessSystem, toContent.businessSystemIDBusinessSystem, toContent.additionalIdentifierBusinessSystem, toContent.isThirdPartyBusinessSystem, toContent.assignedUserBusinessSystem] x]
	fromContent cs = BusinessSystem__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7)
		where [c1, c2, c3, c4, c5, c6, c7] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:BusinessSystemID", "tns:AdditionalIdentifier", "tns:IsThirdParty", "tns:AssignedUser"] cs

instance Xmlable BusinessSystemReadOut__ where
	toContent x = [makeToContent ["tns:BusinessSystem", "tns:LogMessageCollection"] [toContent.businessSystemBusinessSystemReadOut, toContent.logMessageCollectionBusinessSystemReadOut] x]
	fromContent cs = BusinessSystemReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:BusinessSystem", "tns:LogMessageCollection"] cs

instance Xmlable BusinessSystemIdentifierCollection__ where
	toContent x = [makeToContent ["tns:BusinessSystemID"] [toContent.businessSystemIDBusinessSystemIdentifierCollection] x]
	fromContent cs = BusinessSystemIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:BusinessSystemID"] cs

instance Xmlable BusinessSystemCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:BusinessSystem"] [toContent.changeListIDBusinessSystemCreateChangeIn, toContent.businessSystemBusinessSystemCreateChangeIn] x]
	fromContent cs = BusinessSystemCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:BusinessSystem"] cs

instance Xmlable ArrayOfBusinessSystemRestricted__ where
	toContent x = [makeToContent ["tns:BusinessSystemRestricted"] [toContent.businessSystemRestrictedArrayOfBusinessSystemRestricted] x]
	fromContent cs = ArrayOfBusinessSystemRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:BusinessSystemRestricted"] cs

instance Xmlable ArrayOfBusinessSystem__ where
	toContent x = [makeToContent ["tns:BusinessSystem"] [toContent.businessSystemArrayOfBusinessSystem] x]
	fromContent cs = ArrayOfBusinessSystem__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:BusinessSystem"] cs

instance Xmlable ChangeListGetObjectIdentifiersOut__ where
	toContent x = [makeToContent ["tns:PartyID", "tns:BusinessSystemID", "tns:BusinessComponentID", "tns:IntegrationProcessID", "tns:CommunicationChannelID", "tns:SenderAgreementID", "tns:ReceiverAgreementID", "tns:ReceiverDeterminationID", "tns:InterfaceDeterminationID", "tns:ValueMappingID", "tns:ConfigurationScenarioID", "tns:LogMessageCollection"] [toContent.partyIDChangeListGetObjectIdentifiersOut, toContent.businessSystemIDChangeListGetObjectIdentifiersOut, toContent.businessComponentIDChangeListGetObjectIdentifiersOut, toContent.integrationProcessIDChangeListGetObjectIdentifiersOut, toContent.communicationChannelIDChangeListGetObjectIdentifiersOut, toContent.senderAgreementIDChangeListGetObjectIdentifiersOut, toContent.receiverAgreementIDChangeListGetObjectIdentifiersOut, toContent.receiverDeterminationIDChangeListGetObjectIdentifiersOut, toContent.interfaceDeterminationIDChangeListGetObjectIdentifiersOut, toContent.valueMappingIDChangeListGetObjectIdentifiersOut, toContent.configurationScenarioIDChangeListGetObjectIdentifiersOut, toContent.logMessageCollectionChangeListGetObjectIdentifiersOut] x]
	fromContent cs = ChangeListGetObjectIdentifiersOut__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9) (fromContent c10) (fromContent c11) (fromContent c12)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12] = forFromContent nss ["tns:PartyID", "tns:BusinessSystemID", "tns:BusinessComponentID", "tns:IntegrationProcessID", "tns:CommunicationChannelID", "tns:SenderAgreementID", "tns:ReceiverAgreementID", "tns:ReceiverDeterminationID", "tns:InterfaceDeterminationID", "tns:ValueMappingID", "tns:ConfigurationScenarioID", "tns:LogMessageCollection"] cs

instance Xmlable ChangeListGetStateOut__ where
	toContent x = [makeToContent ["tns:State", "tns:LogMessageCollection"] [toContent.stateChangeListGetStateOut, toContent.logMessageCollectionChangeListGetStateOut] x]
	fromContent cs = ChangeListGetStateOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:State", "tns:LogMessageCollection"] cs

instance Xmlable ChangeListCacheState__ where
	toContent x = [makeToContent ["tns:Consumer", "tns:NotificationState", "tns:RefreshState", "tns:ErrorMessage"] [toContent.consumerChangeListCacheState, toContent.notificationStateChangeListCacheState, toContent.refreshStateChangeListCacheState, toContent.errorMessageChangeListCacheState] x]
	fromContent cs = ChangeListCacheState__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4)
		where [c1, c2, c3, c4] = forFromContent nss ["tns:Consumer", "tns:NotificationState", "tns:RefreshState", "tns:ErrorMessage"] cs

instance Xmlable ChangeListCreateOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:LogMessageCollection"] [toContent.changeListIDChangeListCreateOut, toContent.logMessageCollectionChangeListCreateOut] x]
	fromContent cs = ChangeListCreateOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:LogMessageCollection"] cs

instance Xmlable ChangeListGetCacheStateOut__ where
	toContent x = [makeToContent ["tns:CacheState", "tns:LogMessageCollection"] [toContent.cacheStateChangeListGetCacheStateOut, toContent.logMessageCollectionChangeListGetCacheStateOut] x]
	fromContent cs = ChangeListGetCacheStateOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:CacheState", "tns:LogMessageCollection"] cs

instance Xmlable ArrayOfCommunicationChannelID__ where
	toContent x = [makeToContent ["tns:CommunicationChannelID"] [toContent.communicationChannelIDArrayOfCommunicationChannelID] x]
	fromContent cs = ArrayOfCommunicationChannelID__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:CommunicationChannelID"] cs

instance Xmlable ArrayOfMessageHeaderID__ where
	toContent x = [makeToContent ["tns:MessageHeaderID"] [toContent.messageHeaderIDArrayOfMessageHeaderID] x]
	fromContent cs = ArrayOfMessageHeaderID__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:MessageHeaderID"] cs

instance Xmlable ArrayOfChangeListCacheState__ where
	toContent x = [makeToContent ["tns:ChangeListCacheState"] [toContent.changeListCacheStateArrayOfChangeListCacheState] x]
	fromContent cs = ArrayOfChangeListCacheState__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ChangeListCacheState"] cs

instance Xmlable ArrayOfLogMessageItem__ where
	toContent x = [makeToContent ["tns:LogMessageItem"] [toContent.logMessageItemArrayOfLogMessageItem] x]
	fromContent cs = ArrayOfLogMessageItem__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:LogMessageItem"] cs

instance Xmlable GenericTableRow__ where
	toContent x = [makeToContent ["tns:ValueTableCell"] [toContent.valueTableCellGenericTableRow] x]
	fromContent cs = GenericTableRow__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ValueTableCell"] cs

instance Xmlable GenericTableRowTableCell__ where
	toContent x = [makeToContent ["tns:ColumnName", "tns:Value"] [toContent.columnNameGenericTableRowTableCell, toContent.valueGenericTableRowTableCell] x]
	fromContent cs = GenericTableRowTableCell__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ColumnName", "tns:Value"] cs

instance Xmlable CommunicationChannelTemplateBased__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:CommunicationChannelID", "tns:ChannelTemplate", "tns:AdapterEngineName", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:ModuleProcess", "tns:SenderIdentifier", "tns:ReceiverIdentifier"] [toContent.masterLanguageCommunicationChannelTemplateBased, toContent.administrativeDataCommunicationChannelTemplateBased, toContent.descriptionCommunicationChannelTemplateBased, toContent.communicationChannelIDCommunicationChannelTemplateBased, toContent.channelTemplateCommunicationChannelTemplateBased, toContent.adapterEngineNameCommunicationChannelTemplateBased, toContent.adapterSpecificAttributeCommunicationChannelTemplateBased, toContent.adapterSpecificTableAttributeCommunicationChannelTemplateBased, toContent.moduleProcessCommunicationChannelTemplateBased, toContent.senderIdentifierCommunicationChannelTemplateBased, toContent.receiverIdentifierCommunicationChannelTemplateBased] x]
	fromContent cs = CommunicationChannelTemplateBased__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9) (fromContent c10) (fromContent c11)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:CommunicationChannelID", "tns:ChannelTemplate", "tns:AdapterEngineName", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:ModuleProcess", "tns:SenderIdentifier", "tns:ReceiverIdentifier"] cs

instance Xmlable GenericProperty__ where
	toContent x = [makeToContent ["tns:Name", "tns:Value"] [toContent.nameGenericProperty, toContent.valueGenericProperty] x]
	fromContent cs = GenericProperty__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:Name", "tns:Value"] cs

instance Xmlable GenericPropertyTable__ where
	toContent x = [makeToContent ["tns:Name", "tns:ValueTableRow"] [toContent.nameGenericPropertyTable, toContent.valueTableRowGenericPropertyTable] x]
	fromContent cs = GenericPropertyTable__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:Name", "tns:ValueTableRow"] cs

instance Xmlable ModuleProcess__ where
	toContent x = [makeToContent ["tns:ProcessStep", "tns:ParameterGroup"] [toContent.processStepModuleProcess, toContent.parameterGroupModuleProcess] x]
	fromContent cs = ModuleProcess__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ProcessStep", "tns:ParameterGroup"] cs

instance Xmlable ProcessStep__ where
	toContent x = [makeToContent ["tns:ModuleName", "tns:ModuleType", "tns:ParameterGroupID"] [toContent.moduleNameProcessStep, toContent.moduleTypeProcessStep, toContent.parameterGroupIDProcessStep] x]
	fromContent cs = ProcessStep__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ModuleName", "tns:ModuleType", "tns:ParameterGroupID"] cs

instance Xmlable ParameterGroup__ where
	toContent x = [makeToContent ["tns:ParameterGroupID", "tns:Parameter"] [toContent.parameterGroupIDParameterGroup, toContent.parameterParameterGroup] x]
	fromContent cs = ParameterGroup__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ParameterGroupID", "tns:Parameter"] cs

instance Xmlable GenericPropertyRestricted__ where
	toContent x = [makeToContent ["tns:Name", "tns:Value"] [toContent.nameGenericPropertyRestricted, toContent.valueGenericPropertyRestricted] x]
	fromContent cs = GenericPropertyRestricted__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:Name", "tns:Value"] cs

instance Xmlable ChannelAdditionalIdentifier__ where
	toContent x = [makeToContent ["tns:schemeID", "tns:schemeAgencyID"] [toContent.schemeIDChannelAdditionalIdentifier, toContent.schemeAgencyIDChannelAdditionalIdentifier] x]
	fromContent cs = ChannelAdditionalIdentifier__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:schemeID", "tns:schemeAgencyID"] cs

instance Xmlable CommunicationChannelQueryOut__ where
	toContent x = [makeToContent ["tns:CommunicationChannelID", "tns:LogMessageCollection"] [toContent.communicationChannelIDCommunicationChannelQueryOut, toContent.logMessageCollectionCommunicationChannelQueryOut] x]
	fromContent cs = CommunicationChannelQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:CommunicationChannelID", "tns:LogMessageCollection"] cs

instance Xmlable CommunicationChannelIdentifierCollection__ where
	toContent x = [makeToContent ["tns:CommunicationChannelID"] [toContent.communicationChannelIDCommunicationChannelIdentifierCollection] x]
	fromContent cs = CommunicationChannelIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:CommunicationChannelID"] cs

instance Xmlable CommunicationChannelCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:CommunicationChannel"] [toContent.changeListIDCommunicationChannelCreateChangeIn, toContent.communicationChannelCommunicationChannelCreateChangeIn] x]
	fromContent cs = CommunicationChannelCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:CommunicationChannel"] cs

instance Xmlable CommunicationChannelRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:CommunicationChannelID", "tns:AdapterMetadata", "tns:Direction", "tns:TransportProtocol", "tns:TransportProtocolVersion", "tns:MessageProtocol", "tns:MessageProtocolVersion", "tns:AdapterEngineName", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:ModuleProcess", "tns:SenderIdentifier", "tns:ReceiverIdentifier"] [toContent.masterLanguageCommunicationChannelRestricted, toContent.administrativeDataCommunicationChannelRestricted, toContent.descriptionCommunicationChannelRestricted, toContent.communicationChannelIDCommunicationChannelRestricted, toContent.adapterMetadataCommunicationChannelRestricted, toContent.directionCommunicationChannelRestricted, toContent.transportProtocolCommunicationChannelRestricted, toContent.transportProtocolVersionCommunicationChannelRestricted, toContent.messageProtocolCommunicationChannelRestricted, toContent.messageProtocolVersionCommunicationChannelRestricted, toContent.adapterEngineNameCommunicationChannelRestricted, toContent.adapterSpecificAttributeCommunicationChannelRestricted, toContent.adapterSpecificTableAttributeCommunicationChannelRestricted, toContent.moduleProcessCommunicationChannelRestricted, toContent.senderIdentifierCommunicationChannelRestricted, toContent.receiverIdentifierCommunicationChannelRestricted] x]
	fromContent cs = CommunicationChannelRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9) (fromContent c10) (fromContent c11) (fromContent c12) (fromContent c13) (fromContent c14) (fromContent c15) (fromContent c16)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:CommunicationChannelID", "tns:AdapterMetadata", "tns:Direction", "tns:TransportProtocol", "tns:TransportProtocolVersion", "tns:MessageProtocol", "tns:MessageProtocolVersion", "tns:AdapterEngineName", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:ModuleProcess", "tns:SenderIdentifier", "tns:ReceiverIdentifier"] cs

instance Xmlable CommunicationChannelCreateFromTemplateIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:CommunicationChannel"] [toContent.changeListIDCommunicationChannelCreateFromTemplateIn, toContent.communicationChannelCommunicationChannelCreateFromTemplateIn] x]
	fromContent cs = CommunicationChannelCreateFromTemplateIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:CommunicationChannel"] cs

instance Xmlable CommunicationChannelReadOut__ where
	toContent x = [makeToContent ["tns:CommunicationChannel", "tns:LogMessageCollection"] [toContent.communicationChannelCommunicationChannelReadOut, toContent.logMessageCollectionCommunicationChannelReadOut] x]
	fromContent cs = CommunicationChannelReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:CommunicationChannel", "tns:LogMessageCollection"] cs

instance Xmlable CommunicationChannel__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:CommunicationChannelID", "tns:AdapterMetadata", "tns:Direction", "tns:TransportProtocol", "tns:TransportProtocolVersion", "tns:MessageProtocol", "tns:MessageProtocolVersion", "tns:AdapterEngineName", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:ModuleProcess", "tns:SenderIdentifier", "tns:ReceiverIdentifier"] [toContent.masterLanguageCommunicationChannel, toContent.administrativeDataCommunicationChannel, toContent.descriptionCommunicationChannel, toContent.communicationChannelIDCommunicationChannel, toContent.adapterMetadataCommunicationChannel, toContent.directionCommunicationChannel, toContent.transportProtocolCommunicationChannel, toContent.transportProtocolVersionCommunicationChannel, toContent.messageProtocolCommunicationChannel, toContent.messageProtocolVersionCommunicationChannel, toContent.adapterEngineNameCommunicationChannel, toContent.adapterSpecificAttributeCommunicationChannel, toContent.adapterSpecificTableAttributeCommunicationChannel, toContent.moduleProcessCommunicationChannel, toContent.senderIdentifierCommunicationChannel, toContent.receiverIdentifierCommunicationChannel] x]
	fromContent cs = CommunicationChannel__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9) (fromContent c10) (fromContent c11) (fromContent c12) (fromContent c13) (fromContent c14) (fromContent c15) (fromContent c16)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:CommunicationChannelID", "tns:AdapterMetadata", "tns:Direction", "tns:TransportProtocol", "tns:TransportProtocolVersion", "tns:MessageProtocol", "tns:MessageProtocolVersion", "tns:AdapterEngineName", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:ModuleProcess", "tns:SenderIdentifier", "tns:ReceiverIdentifier"] cs

instance Xmlable CommunicationChannelReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:CommunicationChannelID"] [toContent.readContextCommunicationChannelReadIn, toContent.communicationChannelIDCommunicationChannelReadIn] x]
	fromContent cs = CommunicationChannelReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:CommunicationChannelID"] cs

instance Xmlable CommunicationChannelOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:CommunicationChannel", "tns:LogMessageCollection"] [toContent.changeListIDCommunicationChannelOpenForEditOut, toContent.communicationChannelCommunicationChannelOpenForEditOut, toContent.logMessageCollectionCommunicationChannelOpenForEditOut] x]
	fromContent cs = CommunicationChannelOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:CommunicationChannel", "tns:LogMessageCollection"] cs

instance Xmlable CommunicationChannelQueryIn__ where
	toContent x = [makeToContent ["tns:CommunicationChannelID", "tns:Description", "tns:AdministrativeData"] [toContent.communicationChannelIDCommunicationChannelQueryIn, toContent.descriptionCommunicationChannelQueryIn, toContent.administrativeDataCommunicationChannelQueryIn] x]
	fromContent cs = CommunicationChannelQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:CommunicationChannelID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable CommunicationChannelDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:CommunicationChannelID"] [toContent.changeListIDCommunicationChannelDeleteOpenForEditIn, toContent.communicationChannelIDCommunicationChannelDeleteOpenForEditIn] x]
	fromContent cs = CommunicationChannelDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:CommunicationChannelID"] cs

instance Xmlable ArrayOfGenericPropertyRestricted__ where
	toContent x = [makeToContent ["tns:GenericPropertyRestricted"] [toContent.genericPropertyRestrictedArrayOfGenericPropertyRestricted] x]
	fromContent cs = ArrayOfGenericPropertyRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:GenericPropertyRestricted"] cs

instance Xmlable ArrayOfGenericTableRow__ where
	toContent x = [makeToContent ["tns:GenericTableRow"] [toContent.genericTableRowArrayOfGenericTableRow] x]
	fromContent cs = ArrayOfGenericTableRow__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:GenericTableRow"] cs

instance Xmlable ArrayOfGenericPropertyTable__ where
	toContent x = [makeToContent ["tns:GenericPropertyTable"] [toContent.genericPropertyTableArrayOfGenericPropertyTable] x]
	fromContent cs = ArrayOfGenericPropertyTable__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:GenericPropertyTable"] cs

instance Xmlable ArrayOfCommunicationChannelTemplateBased__ where
	toContent x = [makeToContent ["tns:CommunicationChannelTemplateBased"] [toContent.communicationChannelTemplateBasedArrayOfCommunicationChannelTemplateBased] x]
	fromContent cs = ArrayOfCommunicationChannelTemplateBased__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:CommunicationChannelTemplateBased"] cs

instance Xmlable ArrayOfGenericProperty__ where
	toContent x = [makeToContent ["tns:GenericProperty"] [toContent.genericPropertyArrayOfGenericProperty] x]
	fromContent cs = ArrayOfGenericProperty__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:GenericProperty"] cs

instance Xmlable ArrayOfCommunicationChannelRestricted__ where
	toContent x = [makeToContent ["tns:CommunicationChannelRestricted"] [toContent.communicationChannelRestrictedArrayOfCommunicationChannelRestricted] x]
	fromContent cs = ArrayOfCommunicationChannelRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:CommunicationChannelRestricted"] cs

instance Xmlable ArrayOfGenericTableRowTableCell__ where
	toContent x = [makeToContent ["tns:GenericTableRowTableCell"] [toContent.genericTableRowTableCellArrayOfGenericTableRowTableCell] x]
	fromContent cs = ArrayOfGenericTableRowTableCell__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:GenericTableRowTableCell"] cs

instance Xmlable ArrayOfCommunicationChannel__ where
	toContent x = [makeToContent ["tns:CommunicationChannel"] [toContent.communicationChannelArrayOfCommunicationChannel] x]
	fromContent cs = ArrayOfCommunicationChannel__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:CommunicationChannel"] cs

instance Xmlable ArrayOfParameterGroup__ where
	toContent x = [makeToContent ["tns:ParameterGroup"] [toContent.parameterGroupArrayOfParameterGroup] x]
	fromContent cs = ArrayOfParameterGroup__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ParameterGroup"] cs

instance Xmlable ArrayOfProcessStep__ where
	toContent x = [makeToContent ["tns:ProcessStep"] [toContent.processStepArrayOfProcessStep] x]
	fromContent cs = ArrayOfProcessStep__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ProcessStep"] cs

instance Xmlable PartyQueryIn__ where
	toContent x = [makeToContent ["tns:PartyID", "tns:Description", "tns:AdministrativeData"] [toContent.partyIDPartyQueryIn, toContent.descriptionPartyQueryIn, toContent.administrativeDataPartyQueryIn] x]
	fromContent cs = PartyQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:PartyID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable PartyReadOut__ where
	toContent x = [makeToContent ["tns:Party", "tns:LogMessageCollection"] [toContent.partyPartyReadOut, toContent.logMessageCollectionPartyReadOut] x]
	fromContent cs = PartyReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:Party", "tns:LogMessageCollection"] cs

instance Xmlable Party__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:PartyID", "tns:AdditionalIdentifier"] [toContent.masterLanguageParty, toContent.administrativeDataParty, toContent.descriptionParty, toContent.partyIDParty, toContent.additionalIdentifierParty] x]
	fromContent cs = Party__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5)
		where [c1, c2, c3, c4, c5] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:PartyID", "tns:AdditionalIdentifier"] cs

instance Xmlable PartyAdditionalIdentifier__ where
	toContent x = [makeToContent ["tns:schemeID", "tns:schemeAgencyID", "tns:value"] [toContent.schemeIDPartyAdditionalIdentifier, toContent.schemeAgencyIDPartyAdditionalIdentifier, toContent.valuePartyAdditionalIdentifier] x]
	fromContent cs = PartyAdditionalIdentifier__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:schemeID", "tns:schemeAgencyID", "tns:value"] cs

instance Xmlable PartyRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:PartyID", "tns:AdditionalIdentifier"] [toContent.masterLanguagePartyRestricted, toContent.administrativeDataPartyRestricted, toContent.descriptionPartyRestricted, toContent.partyIDPartyRestricted, toContent.additionalIdentifierPartyRestricted] x]
	fromContent cs = PartyRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5)
		where [c1, c2, c3, c4, c5] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:PartyID", "tns:AdditionalIdentifier"] cs

instance Xmlable PartyReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:PartyID"] [toContent.readContextPartyReadIn, toContent.partyIDPartyReadIn] x]
	fromContent cs = PartyReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:PartyID"] cs

instance Xmlable PartyIdentifierCollection__ where
	toContent x = [makeToContent ["tns:PartyID"] [toContent.partyIDPartyIdentifierCollection] x]
	fromContent cs = PartyIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:PartyID"] cs

instance Xmlable PartyOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:Party", "tns:LogMessageCollection"] [toContent.changeListIDPartyOpenForEditOut, toContent.partyPartyOpenForEditOut, toContent.logMessageCollectionPartyOpenForEditOut] x]
	fromContent cs = PartyOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:Party", "tns:LogMessageCollection"] cs

instance Xmlable PartyQueryOut__ where
	toContent x = [makeToContent ["tns:PartyID", "tns:LogMessageCollection"] [toContent.partyIDPartyQueryOut, toContent.logMessageCollectionPartyQueryOut] x]
	fromContent cs = PartyQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:PartyID", "tns:LogMessageCollection"] cs

instance Xmlable PartyDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:PartyID"] [toContent.changeListIDPartyDeleteOpenForEditIn, toContent.partyIDPartyDeleteOpenForEditIn] x]
	fromContent cs = PartyDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:PartyID"] cs

instance Xmlable PartyCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:Party"] [toContent.changeListIDPartyCreateChangeIn, toContent.partyPartyCreateChangeIn] x]
	fromContent cs = PartyCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:Party"] cs

instance Xmlable ArrayOfPartyRestricted__ where
	toContent x = [makeToContent ["tns:PartyRestricted"] [toContent.partyRestrictedArrayOfPartyRestricted] x]
	fromContent cs = ArrayOfPartyRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:PartyRestricted"] cs

instance Xmlable ArrayOfPartyAdditionalIdentifier__ where
	toContent x = [makeToContent ["tns:PartyAdditionalIdentifier"] [toContent.partyAdditionalIdentifierArrayOfPartyAdditionalIdentifier] x]
	fromContent cs = ArrayOfPartyAdditionalIdentifier__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:PartyAdditionalIdentifier"] cs

instance Xmlable ArrayOfParty__ where
	toContent x = [makeToContent ["tns:Party"] [toContent.partyArrayOfParty] x]
	fromContent cs = ArrayOfParty__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:Party"] cs

instance Xmlable ConfigurationScenarioIdentifierCollection__ where
	toContent x = [makeToContent ["tns:ConfigurationScenarioID"] [toContent.configurationScenarioIDConfigurationScenarioIdentifierCollection] x]
	fromContent cs = ConfigurationScenarioIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ConfigurationScenarioID"] cs

instance Xmlable ConfigurationScenarioCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ConfigurationScenario"] [toContent.changeListIDConfigurationScenarioCreateChangeIn, toContent.configurationScenarioConfigurationScenarioCreateChangeIn] x]
	fromContent cs = ConfigurationScenarioCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:ConfigurationScenario"] cs

instance Xmlable ConfigurationScenarioRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ConfigurationScenarioID", "tns:RepositoryScenario", "tns:Party", "tns:BusinessSystem", "tns:BusinessComponent", "tns:IntegrationProcess", "tns:CommunicationChannel", "tns:SenderAgreement", "tns:ReceiverAgreement", "tns:ReceiverDetermination", "tns:InterfaceDetermination"] [toContent.masterLanguageConfigurationScenarioRestricted, toContent.administrativeDataConfigurationScenarioRestricted, toContent.descriptionConfigurationScenarioRestricted, toContent.configurationScenarioIDConfigurationScenarioRestricted, toContent.repositoryScenarioConfigurationScenarioRestricted, toContent.partyConfigurationScenarioRestricted, toContent.businessSystemConfigurationScenarioRestricted, toContent.businessComponentConfigurationScenarioRestricted, toContent.integrationProcessConfigurationScenarioRestricted, toContent.communicationChannelConfigurationScenarioRestricted, toContent.senderAgreementConfigurationScenarioRestricted, toContent.receiverAgreementConfigurationScenarioRestricted, toContent.receiverDeterminationConfigurationScenarioRestricted, toContent.interfaceDeterminationConfigurationScenarioRestricted] x]
	fromContent cs = ConfigurationScenarioRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9) (fromContent c10) (fromContent c11) (fromContent c12) (fromContent c13) (fromContent c14)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ConfigurationScenarioID", "tns:RepositoryScenario", "tns:Party", "tns:BusinessSystem", "tns:BusinessComponent", "tns:IntegrationProcess", "tns:CommunicationChannel", "tns:SenderAgreement", "tns:ReceiverAgreement", "tns:ReceiverDetermination", "tns:InterfaceDetermination"] cs

instance Xmlable ConfigurationScenarioReadOut__ where
	toContent x = [makeToContent ["tns:ConfigurationScenario", "tns:LogMessageCollection"] [toContent.configurationScenarioConfigurationScenarioReadOut, toContent.logMessageCollectionConfigurationScenarioReadOut] x]
	fromContent cs = ConfigurationScenarioReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ConfigurationScenario", "tns:LogMessageCollection"] cs

instance Xmlable ConfigurationScenario__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ConfigurationScenarioID", "tns:RepositoryScenario", "tns:Party", "tns:BusinessSystem", "tns:BusinessComponent", "tns:IntegrationProcess", "tns:CommunicationChannel", "tns:SenderAgreement", "tns:ReceiverAgreement", "tns:ReceiverDetermination", "tns:InterfaceDetermination"] [toContent.masterLanguageConfigurationScenario, toContent.administrativeDataConfigurationScenario, toContent.descriptionConfigurationScenario, toContent.configurationScenarioIDConfigurationScenario, toContent.repositoryScenarioConfigurationScenario, toContent.partyConfigurationScenario, toContent.businessSystemConfigurationScenario, toContent.businessComponentConfigurationScenario, toContent.integrationProcessConfigurationScenario, toContent.communicationChannelConfigurationScenario, toContent.senderAgreementConfigurationScenario, toContent.receiverAgreementConfigurationScenario, toContent.receiverDeterminationConfigurationScenario, toContent.interfaceDeterminationConfigurationScenario] x]
	fromContent cs = ConfigurationScenario__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9) (fromContent c10) (fromContent c11) (fromContent c12) (fromContent c13) (fromContent c14)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ConfigurationScenarioID", "tns:RepositoryScenario", "tns:Party", "tns:BusinessSystem", "tns:BusinessComponent", "tns:IntegrationProcess", "tns:CommunicationChannel", "tns:SenderAgreement", "tns:ReceiverAgreement", "tns:ReceiverDetermination", "tns:InterfaceDetermination"] cs

instance Xmlable ConfigurationScenarioReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:ConfigurationScenarioID"] [toContent.readContextConfigurationScenarioReadIn, toContent.configurationScenarioIDConfigurationScenarioReadIn] x]
	fromContent cs = ConfigurationScenarioReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:ConfigurationScenarioID"] cs

instance Xmlable ConfigurationScenarioDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ConfigurationScenarioID"] [toContent.changeListIDConfigurationScenarioDeleteOpenForEditIn, toContent.configurationScenarioIDConfigurationScenarioDeleteOpenForEditIn] x]
	fromContent cs = ConfigurationScenarioDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:ConfigurationScenarioID"] cs

instance Xmlable ConfigurationScenarioQueryOut__ where
	toContent x = [makeToContent ["tns:ConfigurationScenarioID", "tns:LogMessageCollection"] [toContent.configurationScenarioIDConfigurationScenarioQueryOut, toContent.logMessageCollectionConfigurationScenarioQueryOut] x]
	fromContent cs = ConfigurationScenarioQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ConfigurationScenarioID", "tns:LogMessageCollection"] cs

instance Xmlable ConfigurationScenarioOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ConfigurationScenario", "tns:LogMessageCollection"] [toContent.changeListIDConfigurationScenarioOpenForEditOut, toContent.configurationScenarioConfigurationScenarioOpenForEditOut, toContent.logMessageCollectionConfigurationScenarioOpenForEditOut] x]
	fromContent cs = ConfigurationScenarioOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:ConfigurationScenario", "tns:LogMessageCollection"] cs

instance Xmlable ConfigurationScenarioQueryIn__ where
	toContent x = [makeToContent ["tns:ConfigurationScenarioID", "tns:Description", "tns:AdministrativeData"] [toContent.configurationScenarioIDConfigurationScenarioQueryIn, toContent.descriptionConfigurationScenarioQueryIn, toContent.administrativeDataConfigurationScenarioQueryIn] x]
	fromContent cs = ConfigurationScenarioQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ConfigurationScenarioID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable ArrayOfConfigurationScenarioRestricted__ where
	toContent x = [makeToContent ["tns:ConfigurationScenarioRestricted"] [toContent.configurationScenarioRestrictedArrayOfConfigurationScenarioRestricted] x]
	fromContent cs = ArrayOfConfigurationScenarioRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ConfigurationScenarioRestricted"] cs

instance Xmlable ArrayOfConfigurationScenario__ where
	toContent x = [makeToContent ["tns:ConfigurationScenario"] [toContent.configurationScenarioArrayOfConfigurationScenario] x]
	fromContent cs = ArrayOfConfigurationScenario__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ConfigurationScenario"] cs

instance Xmlable IntegrationProcessRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:IntegrationProcessID", "tns:RepositoryIntegrationProcess", "tns:AdditionalIdentifier"] [toContent.masterLanguageIntegrationProcessRestricted, toContent.administrativeDataIntegrationProcessRestricted, toContent.descriptionIntegrationProcessRestricted, toContent.integrationProcessIDIntegrationProcessRestricted, toContent.repositoryIntegrationProcessIntegrationProcessRestricted, toContent.additionalIdentifierIntegrationProcessRestricted] x]
	fromContent cs = IntegrationProcessRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6)
		where [c1, c2, c3, c4, c5, c6] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:IntegrationProcessID", "tns:RepositoryIntegrationProcess", "tns:AdditionalIdentifier"] cs

instance Xmlable IntegrationProcessIdentifierCollection__ where
	toContent x = [makeToContent ["tns:IntegrationProcessID"] [toContent.integrationProcessIDIntegrationProcessIdentifierCollection] x]
	fromContent cs = IntegrationProcessIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:IntegrationProcessID"] cs

instance Xmlable IntegrationProcessCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:IntegrationProcess"] [toContent.changeListIDIntegrationProcessCreateChangeIn, toContent.integrationProcessIntegrationProcessCreateChangeIn] x]
	fromContent cs = IntegrationProcessCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:IntegrationProcess"] cs

instance Xmlable IntegrationProcess__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:IntegrationProcessID", "tns:RepositoryIntegrationProcess", "tns:AdditionalIdentifier"] [toContent.masterLanguageIntegrationProcess, toContent.administrativeDataIntegrationProcess, toContent.descriptionIntegrationProcess, toContent.integrationProcessIDIntegrationProcess, toContent.repositoryIntegrationProcessIntegrationProcess, toContent.additionalIdentifierIntegrationProcess] x]
	fromContent cs = IntegrationProcess__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6)
		where [c1, c2, c3, c4, c5, c6] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:IntegrationProcessID", "tns:RepositoryIntegrationProcess", "tns:AdditionalIdentifier"] cs

instance Xmlable IntegrationProcessQueryOut__ where
	toContent x = [makeToContent ["tns:IntegrationProcessID", "tns:LogMessageCollection"] [toContent.integrationProcessIDIntegrationProcessQueryOut, toContent.logMessageCollectionIntegrationProcessQueryOut] x]
	fromContent cs = IntegrationProcessQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:IntegrationProcessID", "tns:LogMessageCollection"] cs

instance Xmlable IntegrationProcessDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:IntegrationProcessID"] [toContent.changeListIDIntegrationProcessDeleteOpenForEditIn, toContent.integrationProcessIDIntegrationProcessDeleteOpenForEditIn] x]
	fromContent cs = IntegrationProcessDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:IntegrationProcessID"] cs

instance Xmlable IntegrationProcessReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:IntegrationProcessID"] [toContent.readContextIntegrationProcessReadIn, toContent.integrationProcessIDIntegrationProcessReadIn] x]
	fromContent cs = IntegrationProcessReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:IntegrationProcessID"] cs

instance Xmlable IntegrationProcessReadOut__ where
	toContent x = [makeToContent ["tns:IntegrationProcess", "tns:LogMessageCollection"] [toContent.integrationProcessIntegrationProcessReadOut, toContent.logMessageCollectionIntegrationProcessReadOut] x]
	fromContent cs = IntegrationProcessReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:IntegrationProcess", "tns:LogMessageCollection"] cs

instance Xmlable IntegrationProcessQueryIn__ where
	toContent x = [makeToContent ["tns:IntegrationProcessID", "tns:Description", "tns:AdministrativeData"] [toContent.integrationProcessIDIntegrationProcessQueryIn, toContent.descriptionIntegrationProcessQueryIn, toContent.administrativeDataIntegrationProcessQueryIn] x]
	fromContent cs = IntegrationProcessQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:IntegrationProcessID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable ArrayOfIntegrationProcessRestricted__ where
	toContent x = [makeToContent ["tns:IntegrationProcessRestricted"] [toContent.integrationProcessRestrictedArrayOfIntegrationProcessRestricted] x]
	fromContent cs = ArrayOfIntegrationProcessRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:IntegrationProcessRestricted"] cs

instance Xmlable ArrayOfIntegrationProcess__ where
	toContent x = [makeToContent ["tns:IntegrationProcess"] [toContent.integrationProcessArrayOfIntegrationProcess] x]
	fromContent cs = ArrayOfIntegrationProcess__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:IntegrationProcess"] cs

instance Xmlable InterfaceDeterminationOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:InterfaceDetermination", "tns:LogMessageCollection"] [toContent.changeListIDInterfaceDeterminationOpenForEditOut, toContent.interfaceDeterminationInterfaceDeterminationOpenForEditOut, toContent.logMessageCollectionInterfaceDeterminationOpenForEditOut] x]
	fromContent cs = InterfaceDeterminationOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:InterfaceDetermination", "tns:LogMessageCollection"] cs

instance Xmlable InterfaceDetermination__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:InterfaceDeterminationID", "tns:Rule", "tns:PrefixNamespaceMapping", "tns:QualityOfService"] [toContent.masterLanguageInterfaceDetermination, toContent.administrativeDataInterfaceDetermination, toContent.descriptionInterfaceDetermination, toContent.interfaceDeterminationIDInterfaceDetermination, toContent.ruleInterfaceDetermination, toContent.prefixNamespaceMappingInterfaceDetermination, toContent.qualityOfServiceInterfaceDetermination] x]
	fromContent cs = InterfaceDetermination__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7)
		where [c1, c2, c3, c4, c5, c6, c7] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:InterfaceDeterminationID", "tns:Rule", "tns:PrefixNamespaceMapping", "tns:QualityOfService"] cs

instance Xmlable InterfaceDeterminationRule__ where
	toContent x = [makeToContent ["tns:Condition", "tns:Mapping", "tns:Interface"] [toContent.conditionInterfaceDeterminationRule, toContent.mappingInterfaceDeterminationRule, toContent.interfaceInterfaceDeterminationRule] x]
	fromContent cs = InterfaceDeterminationRule__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:Condition", "tns:Mapping", "tns:Interface"] cs

instance Xmlable Condition__ where
	toContent x = [makeToContent ["tns:AtomicConditionBlock"] [toContent.atomicConditionBlockCondition] x]
	fromContent cs = Condition__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:AtomicConditionBlock"] cs

instance Xmlable AtomicConditionBlock__ where
	toContent x = [makeToContent ["tns:AtomicCondition"] [toContent.atomicConditionAtomicConditionBlock] x]
	fromContent cs = AtomicConditionBlock__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:AtomicCondition"] cs

instance Xmlable AtomicCondition__ where
	toContent x = [makeToContent ["tns:Operator", "tns:LeftExtractor", "tns:RightExtractor"] [toContent.operatorAtomicCondition, toContent.leftExtractorAtomicCondition, toContent.rightExtractorAtomicCondition] x]
	fromContent cs = AtomicCondition__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:Operator", "tns:LeftExtractor", "tns:RightExtractor"] cs

instance Xmlable Extractor__ where
	toContent x = [makeToContent ["tns:TypeID", "tns:Value", "tns:Datatype", "tns:ContextObjectName", "tns:ContextObjectNamespace"] [toContent.typeIDExtractor, toContent.valueExtractor, toContent.datatypeExtractor, toContent.contextObjectNameExtractor, toContent.contextObjectNamespaceExtractor] x]
	fromContent cs = Extractor__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5)
		where [c1, c2, c3, c4, c5] = forFromContent nss ["tns:TypeID", "tns:Value", "tns:Datatype", "tns:ContextObjectName", "tns:ContextObjectNamespace"] cs

instance Xmlable PrefixNamespaceMapping__ where
	toContent x = [makeToContent ["tns:URI", "tns:Prefix"] [toContent.uRIPrefixNamespaceMapping, toContent.prefixPrefixNamespaceMapping] x]
	fromContent cs = PrefixNamespaceMapping__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:URI", "tns:Prefix"] cs

instance Xmlable InterfaceDeterminationIdentifierCollection__ where
	toContent x = [makeToContent ["tns:InterfaceDeterminationID"] [toContent.interfaceDeterminationIDInterfaceDeterminationIdentifierCollection] x]
	fromContent cs = InterfaceDeterminationIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:InterfaceDeterminationID"] cs

instance Xmlable InterfaceDeterminationDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:InterfaceDeterminationID"] [toContent.changeListIDInterfaceDeterminationDeleteOpenForEditIn, toContent.interfaceDeterminationIDInterfaceDeterminationDeleteOpenForEditIn] x]
	fromContent cs = InterfaceDeterminationDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:InterfaceDeterminationID"] cs

instance Xmlable InterfaceDeterminationRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:InterfaceDeterminationID", "tns:Rule", "tns:PrefixNamespaceMapping", "tns:QualityOfService"] [toContent.masterLanguageInterfaceDeterminationRestricted, toContent.administrativeDataInterfaceDeterminationRestricted, toContent.descriptionInterfaceDeterminationRestricted, toContent.interfaceDeterminationIDInterfaceDeterminationRestricted, toContent.ruleInterfaceDeterminationRestricted, toContent.prefixNamespaceMappingInterfaceDeterminationRestricted, toContent.qualityOfServiceInterfaceDeterminationRestricted] x]
	fromContent cs = InterfaceDeterminationRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7)
		where [c1, c2, c3, c4, c5, c6, c7] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:InterfaceDeterminationID", "tns:Rule", "tns:PrefixNamespaceMapping", "tns:QualityOfService"] cs

instance Xmlable InterfaceDeterminationReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:InterfaceDeterminationID"] [toContent.readContextInterfaceDeterminationReadIn, toContent.interfaceDeterminationIDInterfaceDeterminationReadIn] x]
	fromContent cs = InterfaceDeterminationReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:InterfaceDeterminationID"] cs

instance Xmlable InterfaceDeterminationQueryOut__ where
	toContent x = [makeToContent ["tns:InterfaceDeterminationID", "tns:LogMessageCollection"] [toContent.interfaceDeterminationIDInterfaceDeterminationQueryOut, toContent.logMessageCollectionInterfaceDeterminationQueryOut] x]
	fromContent cs = InterfaceDeterminationQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:InterfaceDeterminationID", "tns:LogMessageCollection"] cs

instance Xmlable InterfaceDeterminationQueryIn__ where
	toContent x = [makeToContent ["tns:InterfaceDeterminationID", "tns:Description", "tns:AdministrativeData"] [toContent.interfaceDeterminationIDInterfaceDeterminationQueryIn, toContent.descriptionInterfaceDeterminationQueryIn, toContent.administrativeDataInterfaceDeterminationQueryIn] x]
	fromContent cs = InterfaceDeterminationQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:InterfaceDeterminationID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable InterfaceDeterminationCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:InterfaceDetermination"] [toContent.changeListIDInterfaceDeterminationCreateChangeIn, toContent.interfaceDeterminationInterfaceDeterminationCreateChangeIn] x]
	fromContent cs = InterfaceDeterminationCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:InterfaceDetermination"] cs

instance Xmlable InterfaceDeterminationReadOut__ where
	toContent x = [makeToContent ["tns:InterfaceDetermination", "tns:LogMessageCollection"] [toContent.interfaceDeterminationInterfaceDeterminationReadOut, toContent.logMessageCollectionInterfaceDeterminationReadOut] x]
	fromContent cs = InterfaceDeterminationReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:InterfaceDetermination", "tns:LogMessageCollection"] cs

instance Xmlable ArrayOfInterfaceDetermination__ where
	toContent x = [makeToContent ["tns:InterfaceDetermination"] [toContent.interfaceDeterminationArrayOfInterfaceDetermination] x]
	fromContent cs = ArrayOfInterfaceDetermination__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:InterfaceDetermination"] cs

instance Xmlable ArrayOfAtomicCondition__ where
	toContent x = [makeToContent ["tns:AtomicCondition"] [toContent.atomicConditionArrayOfAtomicCondition] x]
	fromContent cs = ArrayOfAtomicCondition__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:AtomicCondition"] cs

instance Xmlable ArrayOfAtomicConditionBlock__ where
	toContent x = [makeToContent ["tns:AtomicConditionBlock"] [toContent.atomicConditionBlockArrayOfAtomicConditionBlock] x]
	fromContent cs = ArrayOfAtomicConditionBlock__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:AtomicConditionBlock"] cs

instance Xmlable ArrayOfPrefixNamespaceMapping__ where
	toContent x = [makeToContent ["tns:PrefixNamespaceMapping"] [toContent.prefixNamespaceMappingArrayOfPrefixNamespaceMapping] x]
	fromContent cs = ArrayOfPrefixNamespaceMapping__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:PrefixNamespaceMapping"] cs

instance Xmlable ArrayOfInterfaceDeterminationRule__ where
	toContent x = [makeToContent ["tns:InterfaceDeterminationRule"] [toContent.interfaceDeterminationRuleArrayOfInterfaceDeterminationRule] x]
	fromContent cs = ArrayOfInterfaceDeterminationRule__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:InterfaceDeterminationRule"] cs

instance Xmlable ArrayOfInterfaceDeterminationRestricted__ where
	toContent x = [makeToContent ["tns:InterfaceDeterminationRestricted"] [toContent.interfaceDeterminationRestrictedArrayOfInterfaceDeterminationRestricted] x]
	fromContent cs = ArrayOfInterfaceDeterminationRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:InterfaceDeterminationRestricted"] cs

instance Xmlable ReceiverAgreementReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:ReceiverAgreementID"] [toContent.readContextReceiverAgreementReadIn, toContent.receiverAgreementIDReceiverAgreementReadIn] x]
	fromContent cs = ReceiverAgreementReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:ReceiverAgreementID"] cs

instance Xmlable ReceiverAgreementQueryIn__ where
	toContent x = [makeToContent ["tns:ReceiverAgreementID", "tns:Description", "tns:AdministrativeData"] [toContent.receiverAgreementIDReceiverAgreementQueryIn, toContent.descriptionReceiverAgreementQueryIn, toContent.administrativeDataReceiverAgreementQueryIn] x]
	fromContent cs = ReceiverAgreementQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ReceiverAgreementID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable ReceiverAgreementDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ReceiverAgreementID"] [toContent.changeListIDReceiverAgreementDeleteOpenForEditIn, toContent.receiverAgreementIDReceiverAgreementDeleteOpenForEditIn] x]
	fromContent cs = ReceiverAgreementDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:ReceiverAgreementID"] cs

instance Xmlable HeaderMapping__ where
	toContent x = [makeToContent ["tns:Sender", "tns:Receiver"] [toContent.senderHeaderMapping, toContent.receiverHeaderMapping] x]
	fromContent cs = HeaderMapping__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:Sender", "tns:Receiver"] cs

instance Xmlable CommunicationPartnerExtractor__ where
	toContent x = [makeToContent ["tns:CommunicationParty", "tns:CommunicationPartySchema", "tns:CommunicationPartyAgency", "tns:CommunicationComponent"] [toContent.communicationPartyCommunicationPartnerExtractor, toContent.communicationPartySchemaCommunicationPartnerExtractor, toContent.communicationPartyAgencyCommunicationPartnerExtractor, toContent.communicationComponentCommunicationPartnerExtractor] x]
	fromContent cs = CommunicationPartnerExtractor__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4)
		where [c1, c2, c3, c4] = forFromContent nss ["tns:CommunicationParty", "tns:CommunicationPartySchema", "tns:CommunicationPartyAgency", "tns:CommunicationComponent"] cs

instance Xmlable ReceiverAgreementQueryOut__ where
	toContent x = [makeToContent ["tns:ReceiverAgreementID", "tns:LogMessageCollection"] [toContent.receiverAgreementIDReceiverAgreementQueryOut, toContent.logMessageCollectionReceiverAgreementQueryOut] x]
	fromContent cs = ReceiverAgreementQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReceiverAgreementID", "tns:LogMessageCollection"] cs

instance Xmlable ReceiverAgreementCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ReceiverAgreement"] [toContent.changeListIDReceiverAgreementCreateChangeIn, toContent.receiverAgreementReceiverAgreementCreateChangeIn] x]
	fromContent cs = ReceiverAgreementCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:ReceiverAgreement"] cs

instance Xmlable ReceiverAgreementRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ReceiverAgreementID", "tns:CommunicationChannel", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:HeaderMapping", "tns:PrefixNamespaceMapping"] [toContent.masterLanguageReceiverAgreementRestricted, toContent.administrativeDataReceiverAgreementRestricted, toContent.descriptionReceiverAgreementRestricted, toContent.receiverAgreementIDReceiverAgreementRestricted, toContent.communicationChannelReceiverAgreementRestricted, toContent.adapterSpecificAttributeReceiverAgreementRestricted, toContent.adapterSpecificTableAttributeReceiverAgreementRestricted, toContent.headerMappingReceiverAgreementRestricted, toContent.prefixNamespaceMappingReceiverAgreementRestricted] x]
	fromContent cs = ReceiverAgreementRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ReceiverAgreementID", "tns:CommunicationChannel", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:HeaderMapping", "tns:PrefixNamespaceMapping"] cs

instance Xmlable ReceiverAgreementIdentifierCollection__ where
	toContent x = [makeToContent ["tns:ReceiverAgreementID"] [toContent.receiverAgreementIDReceiverAgreementIdentifierCollection] x]
	fromContent cs = ReceiverAgreementIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ReceiverAgreementID"] cs

instance Xmlable ReceiverAgreement__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ReceiverAgreementID", "tns:CommunicationChannel", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:HeaderMapping", "tns:PrefixNamespaceMapping"] [toContent.masterLanguageReceiverAgreement, toContent.administrativeDataReceiverAgreement, toContent.descriptionReceiverAgreement, toContent.receiverAgreementIDReceiverAgreement, toContent.communicationChannelReceiverAgreement, toContent.adapterSpecificAttributeReceiverAgreement, toContent.adapterSpecificTableAttributeReceiverAgreement, toContent.headerMappingReceiverAgreement, toContent.prefixNamespaceMappingReceiverAgreement] x]
	fromContent cs = ReceiverAgreement__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ReceiverAgreementID", "tns:CommunicationChannel", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:HeaderMapping", "tns:PrefixNamespaceMapping"] cs

instance Xmlable ReceiverAgreementOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ReceiverAgreement", "tns:LogMessageCollection"] [toContent.changeListIDReceiverAgreementOpenForEditOut, toContent.receiverAgreementReceiverAgreementOpenForEditOut, toContent.logMessageCollectionReceiverAgreementOpenForEditOut] x]
	fromContent cs = ReceiverAgreementOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:ReceiverAgreement", "tns:LogMessageCollection"] cs

instance Xmlable ReceiverAgreementReadOut__ where
	toContent x = [makeToContent ["tns:ReceiverAgreement", "tns:LogMessageCollection"] [toContent.receiverAgreementReceiverAgreementReadOut, toContent.logMessageCollectionReceiverAgreementReadOut] x]
	fromContent cs = ReceiverAgreementReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReceiverAgreement", "tns:LogMessageCollection"] cs

instance Xmlable ArrayOfReceiverAgreement__ where
	toContent x = [makeToContent ["tns:ReceiverAgreement"] [toContent.receiverAgreementArrayOfReceiverAgreement] x]
	fromContent cs = ArrayOfReceiverAgreement__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ReceiverAgreement"] cs

instance Xmlable ArrayOfReceiverAgreementRestricted__ where
	toContent x = [makeToContent ["tns:ReceiverAgreementRestricted"] [toContent.receiverAgreementRestrictedArrayOfReceiverAgreementRestricted] x]
	fromContent cs = ArrayOfReceiverAgreementRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ReceiverAgreementRestricted"] cs

instance Xmlable ReceiverDeterminationQueryIn__ where
	toContent x = [makeToContent ["tns:ReceiverDeterminationID", "tns:Description", "tns:AdministrativeData"] [toContent.receiverDeterminationIDReceiverDeterminationQueryIn, toContent.descriptionReceiverDeterminationQueryIn, toContent.administrativeDataReceiverDeterminationQueryIn] x]
	fromContent cs = ReceiverDeterminationQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ReceiverDeterminationID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable ReceiverDeterminationReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:ReceiverDeterminationID"] [toContent.readContextReceiverDeterminationReadIn, toContent.receiverDeterminationIDReceiverDeterminationReadIn] x]
	fromContent cs = ReceiverDeterminationReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:ReceiverDeterminationID"] cs

instance Xmlable ReceiverDeterminationOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ReceiverDetermination", "tns:LogMessageCollection"] [toContent.changeListIDReceiverDeterminationOpenForEditOut, toContent.receiverDeterminationReceiverDeterminationOpenForEditOut, toContent.logMessageCollectionReceiverDeterminationOpenForEditOut] x]
	fromContent cs = ReceiverDeterminationOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:ReceiverDetermination", "tns:LogMessageCollection"] cs

instance Xmlable ReceiverDetermination__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ReceiverDeterminationID", "tns:Rule", "tns:ReceiverRule", "tns:DynamicReceiverRule", "tns:PrefixNamespaceMapping", "tns:NoReceiverBehaviour", "tns:NoReceiverReceiver"] [toContent.masterLanguageReceiverDetermination, toContent.administrativeDataReceiverDetermination, toContent.descriptionReceiverDetermination, toContent.receiverDeterminationIDReceiverDetermination, toContent.ruleReceiverDetermination, toContent.receiverRuleReceiverDetermination, toContent.dynamicReceiverRuleReceiverDetermination, toContent.prefixNamespaceMappingReceiverDetermination, toContent.noReceiverBehaviourReceiverDetermination, toContent.noReceiverReceiverReceiverDetermination] x]
	fromContent cs = ReceiverDetermination__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9) (fromContent c10)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ReceiverDeterminationID", "tns:Rule", "tns:ReceiverRule", "tns:DynamicReceiverRule", "tns:PrefixNamespaceMapping", "tns:NoReceiverBehaviour", "tns:NoReceiverReceiver"] cs

instance Xmlable ReceiverDeterminationRule__ where
	toContent x = [makeToContent ["tns:Condition", "tns:Receiver"] [toContent.conditionReceiverDeterminationRule, toContent.receiverReceiverDeterminationRule] x]
	fromContent cs = ReceiverDeterminationRule__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:Condition", "tns:Receiver"] cs

instance Xmlable ReceiverDeterminationMapping__ where
	toContent x = [makeToContent ["tns:Mapping"] [toContent.mappingReceiverDeterminationMapping] x]
	fromContent cs = ReceiverDeterminationMapping__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:Mapping"] cs

instance Xmlable ReceiverDeterminationDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ReceiverDeterminationID"] [toContent.changeListIDReceiverDeterminationDeleteOpenForEditIn, toContent.receiverDeterminationIDReceiverDeterminationDeleteOpenForEditIn] x]
	fromContent cs = ReceiverDeterminationDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:ReceiverDeterminationID"] cs

instance Xmlable ReceiverDeterminationCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ReceiverDetermination"] [toContent.changeListIDReceiverDeterminationCreateChangeIn, toContent.receiverDeterminationReceiverDeterminationCreateChangeIn] x]
	fromContent cs = ReceiverDeterminationCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:ReceiverDetermination"] cs

instance Xmlable ReceiverDeterminationRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ReceiverDeterminationID", "tns:Rule", "tns:DynamicReceiverRule", "tns:PrefixNamespaceMapping", "tns:NoReceiverBehaviour", "tns:NoReceiverReceiver"] [toContent.masterLanguageReceiverDeterminationRestricted, toContent.administrativeDataReceiverDeterminationRestricted, toContent.descriptionReceiverDeterminationRestricted, toContent.receiverDeterminationIDReceiverDeterminationRestricted, toContent.ruleReceiverDeterminationRestricted, toContent.dynamicReceiverRuleReceiverDeterminationRestricted, toContent.prefixNamespaceMappingReceiverDeterminationRestricted, toContent.noReceiverBehaviourReceiverDeterminationRestricted, toContent.noReceiverReceiverReceiverDeterminationRestricted] x]
	fromContent cs = ReceiverDeterminationRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8) (fromContent c9)
		where [c1, c2, c3, c4, c5, c6, c7, c8, c9] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ReceiverDeterminationID", "tns:Rule", "tns:DynamicReceiverRule", "tns:PrefixNamespaceMapping", "tns:NoReceiverBehaviour", "tns:NoReceiverReceiver"] cs

instance Xmlable ReceiverDeterminationIdentifierCollection__ where
	toContent x = [makeToContent ["tns:ReceiverDeterminationID"] [toContent.receiverDeterminationIDReceiverDeterminationIdentifierCollection] x]
	fromContent cs = ReceiverDeterminationIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ReceiverDeterminationID"] cs

instance Xmlable ReceiverDeterminationQueryOut__ where
	toContent x = [makeToContent ["tns:ReceiverDeterminationID", "tns:LogMessageCollection"] [toContent.receiverDeterminationIDReceiverDeterminationQueryOut, toContent.logMessageCollectionReceiverDeterminationQueryOut] x]
	fromContent cs = ReceiverDeterminationQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReceiverDeterminationID", "tns:LogMessageCollection"] cs

instance Xmlable ReceiverDeterminationReadOut__ where
	toContent x = [makeToContent ["tns:ReceiverDetermination", "tns:LogMessageCollection"] [toContent.receiverDeterminationReceiverDeterminationReadOut, toContent.logMessageCollectionReceiverDeterminationReadOut] x]
	fromContent cs = ReceiverDeterminationReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReceiverDetermination", "tns:LogMessageCollection"] cs

instance Xmlable ArrayOfReceiverDeterminationRestricted__ where
	toContent x = [makeToContent ["tns:ReceiverDeterminationRestricted"] [toContent.receiverDeterminationRestrictedArrayOfReceiverDeterminationRestricted] x]
	fromContent cs = ArrayOfReceiverDeterminationRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ReceiverDeterminationRestricted"] cs

instance Xmlable ArrayOfCommunicationPartnerExtractor__ where
	toContent x = [makeToContent ["tns:CommunicationPartnerExtractor"] [toContent.communicationPartnerExtractorArrayOfCommunicationPartnerExtractor] x]
	fromContent cs = ArrayOfCommunicationPartnerExtractor__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:CommunicationPartnerExtractor"] cs

instance Xmlable ArrayOfReceiverDeterminationMapping__ where
	toContent x = [makeToContent ["tns:ReceiverDeterminationMapping"] [toContent.receiverDeterminationMappingArrayOfReceiverDeterminationMapping] x]
	fromContent cs = ArrayOfReceiverDeterminationMapping__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ReceiverDeterminationMapping"] cs

instance Xmlable ArrayOfReceiverDetermination__ where
	toContent x = [makeToContent ["tns:ReceiverDetermination"] [toContent.receiverDeterminationArrayOfReceiverDetermination] x]
	fromContent cs = ArrayOfReceiverDetermination__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ReceiverDetermination"] cs

instance Xmlable ArrayOfReceiverDeterminationRule__ where
	toContent x = [makeToContent ["tns:ReceiverDeterminationRule"] [toContent.receiverDeterminationRuleArrayOfReceiverDeterminationRule] x]
	fromContent cs = ArrayOfReceiverDeterminationRule__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ReceiverDeterminationRule"] cs

instance Xmlable SenderAgreementQueryOut__ where
	toContent x = [makeToContent ["tns:SenderAgreementID", "tns:LogMessageCollection"] [toContent.senderAgreementIDSenderAgreementQueryOut, toContent.logMessageCollectionSenderAgreementQueryOut] x]
	fromContent cs = SenderAgreementQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:SenderAgreementID", "tns:LogMessageCollection"] cs

instance Xmlable SenderAgreementQueryIn__ where
	toContent x = [makeToContent ["tns:SenderAgreementID", "tns:Description", "tns:AdministrativeData"] [toContent.senderAgreementIDSenderAgreementQueryIn, toContent.descriptionSenderAgreementQueryIn, toContent.administrativeDataSenderAgreementQueryIn] x]
	fromContent cs = SenderAgreementQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:SenderAgreementID", "tns:Description", "tns:AdministrativeData"] cs

instance Xmlable SenderAgreement__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:SenderAgreementID", "tns:CommunicationChannel", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:AssignedUser"] [toContent.masterLanguageSenderAgreement, toContent.administrativeDataSenderAgreement, toContent.descriptionSenderAgreement, toContent.senderAgreementIDSenderAgreement, toContent.communicationChannelSenderAgreement, toContent.adapterSpecificAttributeSenderAgreement, toContent.adapterSpecificTableAttributeSenderAgreement, toContent.assignedUserSenderAgreement] x]
	fromContent cs = SenderAgreement__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8)
		where [c1, c2, c3, c4, c5, c6, c7, c8] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:SenderAgreementID", "tns:CommunicationChannel", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:AssignedUser"] cs

instance Xmlable SenderAgreementDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:SenderAgreementID"] [toContent.changeListIDSenderAgreementDeleteOpenForEditIn, toContent.senderAgreementIDSenderAgreementDeleteOpenForEditIn] x]
	fromContent cs = SenderAgreementDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:SenderAgreementID"] cs

instance Xmlable SenderAgreementRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:SenderAgreementID", "tns:CommunicationChannel", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:AssignedUser"] [toContent.masterLanguageSenderAgreementRestricted, toContent.administrativeDataSenderAgreementRestricted, toContent.descriptionSenderAgreementRestricted, toContent.senderAgreementIDSenderAgreementRestricted, toContent.communicationChannelSenderAgreementRestricted, toContent.adapterSpecificAttributeSenderAgreementRestricted, toContent.adapterSpecificTableAttributeSenderAgreementRestricted, toContent.assignedUserSenderAgreementRestricted] x]
	fromContent cs = SenderAgreementRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6) (fromContent c7) (fromContent c8)
		where [c1, c2, c3, c4, c5, c6, c7, c8] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:SenderAgreementID", "tns:CommunicationChannel", "tns:AdapterSpecificAttribute", "tns:AdapterSpecificTableAttribute", "tns:AssignedUser"] cs

instance Xmlable SenderAgreementReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:SenderAgreementID"] [toContent.readContextSenderAgreementReadIn, toContent.senderAgreementIDSenderAgreementReadIn] x]
	fromContent cs = SenderAgreementReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:SenderAgreementID"] cs

instance Xmlable SenderAgreementIdentifierCollection__ where
	toContent x = [makeToContent ["tns:SenderAgreementID"] [toContent.senderAgreementIDSenderAgreementIdentifierCollection] x]
	fromContent cs = SenderAgreementIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:SenderAgreementID"] cs

instance Xmlable SenderAgreementReadOut__ where
	toContent x = [makeToContent ["tns:SenderAgreement", "tns:LogMessageCollection"] [toContent.senderAgreementSenderAgreementReadOut, toContent.logMessageCollectionSenderAgreementReadOut] x]
	fromContent cs = SenderAgreementReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:SenderAgreement", "tns:LogMessageCollection"] cs

instance Xmlable SenderAgreementOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:SenderAgreement", "tns:LogMessageCollection"] [toContent.changeListIDSenderAgreementOpenForEditOut, toContent.senderAgreementSenderAgreementOpenForEditOut, toContent.logMessageCollectionSenderAgreementOpenForEditOut] x]
	fromContent cs = SenderAgreementOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:SenderAgreement", "tns:LogMessageCollection"] cs

instance Xmlable SenderAgreementCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:SenderAgreement"] [toContent.changeListIDSenderAgreementCreateChangeIn, toContent.senderAgreementSenderAgreementCreateChangeIn] x]
	fromContent cs = SenderAgreementCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:SenderAgreement"] cs

instance Xmlable ArrayOfSenderAgreementRestricted__ where
	toContent x = [makeToContent ["tns:SenderAgreementRestricted"] [toContent.senderAgreementRestrictedArrayOfSenderAgreementRestricted] x]
	fromContent cs = ArrayOfSenderAgreementRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:SenderAgreementRestricted"] cs

instance Xmlable ArrayOfSenderAgreement__ where
	toContent x = [makeToContent ["tns:SenderAgreement"] [toContent.senderAgreementArrayOfSenderAgreement] x]
	fromContent cs = ArrayOfSenderAgreement__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:SenderAgreement"] cs

instance Xmlable ValueMappingRestricted__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ValueMappingID", "tns:GroupName", "tns:Representation"] [toContent.masterLanguageValueMappingRestricted, toContent.administrativeDataValueMappingRestricted, toContent.descriptionValueMappingRestricted, toContent.valueMappingIDValueMappingRestricted, toContent.groupNameValueMappingRestricted, toContent.representationValueMappingRestricted] x]
	fromContent cs = ValueMappingRestricted__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6)
		where [c1, c2, c3, c4, c5, c6] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ValueMappingID", "tns:GroupName", "tns:Representation"] cs

instance Xmlable ValueMappingRepresentation__ where
	toContent x = [makeToContent ["tns:schemeID", "tns:schemeAgencyID", "tns:value"] [toContent.schemeIDValueMappingRepresentation, toContent.schemeAgencyIDValueMappingRepresentation, toContent.valueValueMappingRepresentation] x]
	fromContent cs = ValueMappingRepresentation__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:schemeID", "tns:schemeAgencyID", "tns:value"] cs

instance Xmlable ValueMappingQueryIn__ where
	toContent x = [makeToContent ["tns:ValueMappingID", "tns:Description", "tns:AdministrativeData", "tns:GroupName", "tns:Representation"] [toContent.valueMappingIDValueMappingQueryIn, toContent.descriptionValueMappingQueryIn, toContent.administrativeDataValueMappingQueryIn, toContent.groupNameValueMappingQueryIn, toContent.representationValueMappingQueryIn] x]
	fromContent cs = ValueMappingQueryIn__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5)
		where [c1, c2, c3, c4, c5] = forFromContent nss ["tns:ValueMappingID", "tns:Description", "tns:AdministrativeData", "tns:GroupName", "tns:Representation"] cs

instance Xmlable ValueMappingReadOut__ where
	toContent x = [makeToContent ["tns:ValueMapping", "tns:LogMessageCollection"] [toContent.valueMappingValueMappingReadOut, toContent.logMessageCollectionValueMappingReadOut] x]
	fromContent cs = ValueMappingReadOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ValueMapping", "tns:LogMessageCollection"] cs

instance Xmlable ValueMapping__ where
	toContent x = [makeToContent ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ValueMappingID", "tns:GroupName", "tns:Representation"] [toContent.masterLanguageValueMapping, toContent.administrativeDataValueMapping, toContent.descriptionValueMapping, toContent.valueMappingIDValueMapping, toContent.groupNameValueMapping, toContent.representationValueMapping] x]
	fromContent cs = ValueMapping__ (fromContent c1) (fromContent c2) (fromContent c3) (fromContent c4) (fromContent c5) (fromContent c6)
		where [c1, c2, c3, c4, c5, c6] = forFromContent nss ["tns:MasterLanguage", "tns:AdministrativeData", "tns:Description", "tns:ValueMappingID", "tns:GroupName", "tns:Representation"] cs

instance Xmlable ValueMappingQueryOut__ where
	toContent x = [makeToContent ["tns:ValueMappingID", "tns:LogMessageCollection"] [toContent.valueMappingIDValueMappingQueryOut, toContent.logMessageCollectionValueMappingQueryOut] x]
	fromContent cs = ValueMappingQueryOut__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ValueMappingID", "tns:LogMessageCollection"] cs

instance Xmlable ValueMappingIdentifierCollection__ where
	toContent x = [makeToContent ["tns:ValueMappingID"] [toContent.valueMappingIDValueMappingIdentifierCollection] x]
	fromContent cs = ValueMappingIdentifierCollection__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ValueMappingID"] cs

instance Xmlable ValueMappingReadIn__ where
	toContent x = [makeToContent ["tns:ReadContext", "tns:ValueMappingID"] [toContent.readContextValueMappingReadIn, toContent.valueMappingIDValueMappingReadIn] x]
	fromContent cs = ValueMappingReadIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ReadContext", "tns:ValueMappingID"] cs

instance Xmlable ValueMappingDeleteOpenForEditIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ValueMappingID"] [toContent.changeListIDValueMappingDeleteOpenForEditIn, toContent.valueMappingIDValueMappingDeleteOpenForEditIn] x]
	fromContent cs = ValueMappingDeleteOpenForEditIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:ValueMappingID"] cs

instance Xmlable ValueMappingCreateChangeIn__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ValueMapping"] [toContent.changeListIDValueMappingCreateChangeIn, toContent.valueMappingValueMappingCreateChangeIn] x]
	fromContent cs = ValueMappingCreateChangeIn__ (fromContent c1) (fromContent c2)
		where [c1, c2] = forFromContent nss ["tns:ChangeListID", "tns:ValueMapping"] cs

instance Xmlable ValueMappingOpenForEditOut__ where
	toContent x = [makeToContent ["tns:ChangeListID", "tns:ValueMapping", "tns:LogMessageCollection"] [toContent.changeListIDValueMappingOpenForEditOut, toContent.valueMappingValueMappingOpenForEditOut, toContent.logMessageCollectionValueMappingOpenForEditOut] x]
	fromContent cs = ValueMappingOpenForEditOut__ (fromContent c1) (fromContent c2) (fromContent c3)
		where [c1, c2, c3] = forFromContent nss ["tns:ChangeListID", "tns:ValueMapping", "tns:LogMessageCollection"] cs

instance Xmlable ArrayOfValueMappingRestricted__ where
	toContent x = [makeToContent ["tns:ValueMappingRestricted"] [toContent.valueMappingRestrictedArrayOfValueMappingRestricted] x]
	fromContent cs = ArrayOfValueMappingRestricted__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ValueMappingRestricted"] cs

instance Xmlable ArrayOfValueMapping__ where
	toContent x = [makeToContent ["tns:ValueMapping"] [toContent.valueMappingArrayOfValueMapping] x]
	fromContent cs = ArrayOfValueMapping__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ValueMapping"] cs

instance Xmlable ArrayOfValueMappingRepresentation__ where
	toContent x = [makeToContent ["tns:ValueMappingRepresentation"] [toContent.valueMappingRepresentationArrayOfValueMappingRepresentation] x]
	fromContent cs = ArrayOfValueMappingRepresentation__ (fromContent c1)
		where [c1] = forFromContent nss ["tns:ValueMappingRepresentation"] cs

